@syfthub/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2581 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  APIError: () => APIError,
+  AccountingAccountExistsError: () => AccountingAccountExistsError,
+  AccountingServiceUnavailableError: () => AccountingServiceUnavailableError,
+  AuthenticationError: () => AuthenticationError,
+  AuthorizationError: () => AuthorizationError,
+  ConfigurationError: () => ConfigurationError,
+  InvalidAccountingPasswordError: () => InvalidAccountingPasswordError,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  SyftHubError: () => SyftHubError,
+  UserAlreadyExistsError: () => UserAlreadyExistsError,
+  ValidationError: () => ValidationError
+});
+var SyftHubError, APIError, AuthenticationError, AuthorizationError, NotFoundError, ValidationError, NetworkError, ConfigurationError, UserAlreadyExistsError, AccountingAccountExistsError, InvalidAccountingPasswordError, AccountingServiceUnavailableError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    SyftHubError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "SyftHubError";
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, this.constructor);
+        }
+      }
+    };
+    APIError = class extends SyftHubError {
+      constructor(message, status, data) {
+        super(message);
+        this.status = status;
+        this.data = data;
+        this.name = "APIError";
+      }
+    };
+    AuthenticationError = class extends SyftHubError {
+      constructor(message = "Authentication required") {
+        super(message);
+        this.name = "AuthenticationError";
+      }
+    };
+    AuthorizationError = class extends SyftHubError {
+      constructor(message = "Permission denied") {
+        super(message);
+        this.name = "AuthorizationError";
+      }
+    };
+    NotFoundError = class extends SyftHubError {
+      constructor(message = "Resource not found") {
+        super(message);
+        this.name = "NotFoundError";
+      }
+    };
+    ValidationError = class extends SyftHubError {
+      constructor(message, errors) {
+        super(message);
+        this.errors = errors;
+        this.name = "ValidationError";
+      }
+    };
+    NetworkError = class extends SyftHubError {
+      constructor(message = "Network request failed", cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "NetworkError";
+      }
+    };
+    ConfigurationError = class extends SyftHubError {
+      constructor(message = "Invalid SDK configuration") {
+        super(message);
+        this.name = "ConfigurationError";
+      }
+    };
+    UserAlreadyExistsError = class extends SyftHubError {
+      constructor(message = "Username or email already exists", detail) {
+        super(message);
+        this.detail = detail;
+        this.name = "UserAlreadyExistsError";
+        if (detail && typeof detail === "object" && "field" in detail) {
+          this.field = detail.field;
+        }
+      }
+      /** The field that caused the conflict ("username" or "email") */
+      field;
+    };
+    AccountingAccountExistsError = class extends SyftHubError {
+      constructor(message = "This email already has an account in the accounting service", detail) {
+        super(message);
+        this.detail = detail;
+        this.name = "AccountingAccountExistsError";
+      }
+      /** Indicates that the user needs to provide their existing accounting password */
+      requiresAccountingPassword = true;
+    };
+    InvalidAccountingPasswordError = class extends SyftHubError {
+      constructor(message = "The provided accounting password is invalid", detail) {
+        super(message);
+        this.detail = detail;
+        this.name = "InvalidAccountingPasswordError";
+      }
+    };
+    AccountingServiceUnavailableError = class extends SyftHubError {
+      constructor(message = "Accounting service is unavailable", detail) {
+        super(message);
+        this.detail = detail;
+        this.name = "AccountingServiceUnavailableError";
+      }
+    };
+  }
+});
+
+// src/http.ts
+init_errors();
+
+// src/utils.ts
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+function isISODateString(value) {
+  return typeof value === "string" && ISO_DATE_REGEX.test(value);
+}
+function transformKeys(obj, keyTransformer, parseDates = true) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => transformKeys(item, keyTransformer, parseDates));
+  }
+  if (parseDates && isISODateString(obj)) {
+    return new Date(obj);
+  }
+  if (typeof obj === "object") {
+    const transformed = {};
+    for (const [key, value] of Object.entries(obj)) {
+      transformed[keyTransformer(key)] = transformKeys(value, keyTransformer, parseDates);
+    }
+    return transformed;
+  }
+  return obj;
+}
+function toSnakeCase(obj) {
+  return transformKeys(obj, camelToSnake, false);
+}
+function toCamelCase(obj) {
+  return transformKeys(obj, snakeToCamel, true);
+}
+function buildSearchParams(params) {
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      searchParams.append(camelToSnake(key), String(value));
+    }
+  }
+  return searchParams;
+}
+
+// src/http.ts
+init_errors();
+var HTTPClient = class {
+  /**
+   * Create a new HTTP client.
+   *
+   * @param baseUrl - Base URL for all API requests (without trailing slash)
+   * @param timeout - Default timeout in milliseconds (default: 30000)
+   */
+  constructor(baseUrl, timeout = 3e4) {
+    this.baseUrl = baseUrl;
+    this.timeout = timeout;
+  }
+  accessToken = null;
+  refreshToken = null;
+  isRefreshing = false;
+  refreshPromise = null;
+  /**
+   * Set authentication tokens.
+   */
+  setTokens(access, refresh) {
+    this.accessToken = access;
+    this.refreshToken = refresh;
+  }
+  /**
+   * Get current authentication tokens.
+   */
+  getTokens() {
+    if (!this.accessToken || !this.refreshToken) {
+      return null;
+    }
+    return {
+      accessToken: this.accessToken,
+      refreshToken: this.refreshToken,
+      tokenType: "bearer"
+    };
+  }
+  /**
+   * Clear authentication tokens.
+   */
+  clearTokens() {
+    this.accessToken = null;
+    this.refreshToken = null;
+  }
+  /**
+   * Check if the client has valid tokens.
+   */
+  hasTokens() {
+    return this.accessToken !== null;
+  }
+  /**
+   * Make a GET request.
+   */
+  async get(path, params, options) {
+    return this.request("GET", path, { ...options, params });
+  }
+  /**
+   * Make a POST request.
+   */
+  async post(path, body, options) {
+    return this.request("POST", path, { ...options, body });
+  }
+  /**
+   * Make a PUT request.
+   */
+  async put(path, body, options) {
+    return this.request("PUT", path, { ...options, body });
+  }
+  /**
+   * Make a PATCH request.
+   */
+  async patch(path, body, options) {
+    return this.request("PATCH", path, { ...options, body });
+  }
+  /**
+   * Make a DELETE request.
+   */
+  async delete(path, options) {
+    return this.request("DELETE", path, options);
+  }
+  /**
+   * Make an HTTP request with automatic retry on 401.
+   */
+  async request(method, path, options = {}) {
+    const { includeAuth = true, isFormData = false, timeout, body, params } = options;
+    let url = `${this.baseUrl}${path}`;
+    if (params) {
+      const searchParams = buildSearchParams(params);
+      const queryString = searchParams.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    const headers = {};
+    if (includeAuth && this.accessToken) {
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    }
+    let requestBody;
+    if (body !== void 0) {
+      if (isFormData) {
+        headers["Content-Type"] = "application/x-www-form-urlencoded";
+        const formData = new URLSearchParams();
+        for (const [key, value] of Object.entries(body)) {
+          if (value !== void 0 && value !== null) {
+            formData.append(key, String(value));
+          }
+        }
+        requestBody = formData.toString();
+      } else {
+        headers["Content-Type"] = "application/json";
+        requestBody = JSON.stringify(toSnakeCase(body));
+      }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout ?? this.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: requestBody,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status === 401 && includeAuth && this.refreshToken) {
+        await this.attemptTokenRefresh();
+        return this.request(method, path, {
+          ...options,
+          // Mark that we shouldn't retry again to prevent infinite loops
+          includeAuth: true
+        });
+      }
+      return await this.handleResponse(response);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof SyftHubError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new NetworkError("Request timed out", error);
+        }
+        throw new NetworkError(error.message, error);
+      }
+      throw new NetworkError("Unknown network error");
+    }
+  }
+  /**
+   * Handle the HTTP response and convert to the expected type.
+   */
+  async handleResponse(response) {
+    let data;
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      try {
+        data = await response.json();
+      } catch {
+        data = null;
+      }
+    } else {
+      const text = await response.text();
+      data = text || null;
+    }
+    if (!response.ok) {
+      this.handleErrorResponse(response.status, data);
+    }
+    return toCamelCase(data);
+  }
+  /**
+   * Handle error responses by throwing appropriate exceptions.
+   */
+  handleErrorResponse(status, data) {
+    const message = this.extractErrorMessage(data);
+    const { code, detail } = this.extractErrorCodeAndDetail(data);
+    if (code) {
+      switch (code) {
+        // User registration errors
+        case "USER_ALREADY_EXISTS":
+          throw new UserAlreadyExistsError(message, detail);
+        // Accounting-related errors
+        case "ACCOUNTING_ACCOUNT_EXISTS":
+          throw new AccountingAccountExistsError(message, detail);
+        case "INVALID_ACCOUNTING_PASSWORD":
+          throw new InvalidAccountingPasswordError(message, detail);
+        case "ACCOUNTING_SERVICE_UNAVAILABLE":
+          throw new AccountingServiceUnavailableError(message, detail);
+      }
+    }
+    switch (status) {
+      case 401:
+        throw new AuthenticationError(message);
+      case 403:
+        throw new AuthorizationError(message);
+      case 404:
+        throw new NotFoundError(message);
+      case 422:
+        throw new ValidationError(message, this.extractValidationErrors(data));
+      default:
+        throw new APIError(message, status, data);
+    }
+  }
+  /**
+   * Extract error code and detail from API response.
+   * Used for accounting-specific error handling.
+   */
+  extractErrorCodeAndDetail(data) {
+    if (!data || typeof data !== "object") {
+      return {};
+    }
+    if ("detail" in data) {
+      const detail = data.detail;
+      if (detail && typeof detail === "object" && "code" in detail) {
+        const innerDetail = detail;
+        return {
+          code: innerDetail.code,
+          detail
+        };
+      }
+    }
+    return {};
+  }
+  /**
+   * Extract error message from API response.
+   */
+  extractErrorMessage(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    if (data && typeof data === "object") {
+      if ("detail" in data) {
+        const detail = data.detail;
+        if (typeof detail === "string") {
+          return detail;
+        }
+        if (Array.isArray(detail) && detail.length > 0) {
+          const firstError = detail[0];
+          if (firstError?.msg) {
+            return firstError.msg;
+          }
+        }
+      }
+      if ("message" in data && typeof data.message === "string") {
+        return data.message;
+      }
+      if ("error" in data && typeof data.error === "string") {
+        return data.error;
+      }
+    }
+    return "An error occurred";
+  }
+  /**
+   * Extract field-level validation errors from API response.
+   */
+  extractValidationErrors(data) {
+    if (!data || typeof data !== "object" || !("detail" in data)) {
+      return void 0;
+    }
+    const detail = data.detail;
+    if (!Array.isArray(detail)) {
+      return void 0;
+    }
+    const errors = {};
+    for (const error of detail) {
+      if (typeof error === "object" && error !== null && "loc" in error && "msg" in error) {
+        const { loc, msg } = error;
+        const field = String(loc[loc.length - 1] ?? "unknown");
+        if (!errors[field]) {
+          errors[field] = [];
+        }
+        errors[field].push(msg);
+      }
+    }
+    return Object.keys(errors).length > 0 ? errors : void 0;
+  }
+  /**
+   * Attempt to refresh the access token using the refresh token.
+   */
+  async attemptTokenRefresh() {
+    if (this.isRefreshing && this.refreshPromise) {
+      await this.refreshPromise;
+      return;
+    }
+    this.isRefreshing = true;
+    this.refreshPromise = (async () => {
+      try {
+        const response = await fetch(`${this.baseUrl}/api/v1/auth/refresh`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ refresh_token: this.refreshToken })
+        });
+        if (!response.ok) {
+          this.clearTokens();
+          throw new AuthenticationError("Token refresh failed");
+        }
+        const data = await response.json();
+        this.accessToken = data.access_token;
+        this.refreshToken = data.refresh_token;
+      } finally {
+        this.isRefreshing = false;
+        this.refreshPromise = null;
+      }
+    })();
+    await this.refreshPromise;
+  }
+};
+
+// src/client.ts
+init_errors();
+
+// src/resources/auth.ts
+init_errors();
+var AuthResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Register a new user account.
+   *
+   * If an accounting service URL is configured (via `accountingServiceUrl` or server default),
+   * the backend will handle accounting integration using a "try-create-first" approach:
+   *
+   * **Accounting Password Behavior:**
+   * - **Not provided**: A secure password is auto-generated and a new accounting account is created.
+   * - **Provided (new user)**: The account is created with your chosen password.
+   * - **Provided (existing user)**: Your password is validated and accounts are linked.
+   *
+   * This means you can set your own accounting password during registration even if you're
+   * a new user - you don't need an existing accounting account first.
+   *
+   * @param input - Registration details (username, email, password, fullName)
+   * @returns The created User
+   * @throws {ValidationError} If input validation fails
+   * @throws {UserAlreadyExistsError} If username or email already exists in SyftHub
+   * @throws {AccountingAccountExistsError} If email already exists in accounting service
+   *         and no `accountingPassword` was provided. Retry with the password.
+   * @throws {InvalidAccountingPasswordError} If the provided accounting password doesn't
+   *         match an existing accounting account
+   * @throws {AccountingServiceUnavailableError} If the accounting service is unreachable
+   *
+   * @example
+   * // Basic registration (auto-generated accounting password)
+   * const user = await client.auth.register({
+   *   username: 'alice',
+   *   email: 'alice@example.com',
+   *   password: 'SecurePass123!',
+   *   fullName: 'Alice'
+   * });
+   *
+   * @example
+   * // Registration with custom accounting password (NEW user)
+   * const user = await client.auth.register({
+   *   username: 'bob',
+   *   email: 'bob@example.com',
+   *   password: 'SecurePass123!',
+   *   fullName: 'Bob',
+   *   accountingPassword: 'MyChosenAccountingPass!'  // Creates account with this password
+   * });
+   *
+   * @example
+   * // Handle existing accounting account
+   * try {
+   *   await client.auth.register({ username, email, password, fullName });
+   * } catch (error) {
+   *   if (error instanceof AccountingAccountExistsError) {
+   *     // Prompt user for their existing accounting password
+   *     const accountingPassword = await promptUser('Enter your existing accounting password:');
+   *     await client.auth.register({ username, email, password, fullName, accountingPassword });
+   *   } else {
+   *     throw error;
+   *   }
+   * }
+   */
+  async register(input) {
+    const response = await this.http.post("/api/v1/auth/register", input, {
+      includeAuth: false
+    });
+    this.http.setTokens(response.accessToken, response.refreshToken);
+    return response.user;
+  }
+  /**
+   * Login with username/email and password.
+   *
+   * Uses OAuth2 password flow (form-urlencoded body).
+   *
+   * @param username - Username or email
+   * @param password - Password
+   * @returns The authenticated User
+   * @throws {AuthenticationError} If credentials are invalid
+   */
+  async login(username, password) {
+    const response = await this.http.post(
+      "/api/v1/auth/login",
+      { username, password },
+      {
+        includeAuth: false,
+        isFormData: true
+      }
+    );
+    this.http.setTokens(response.accessToken, response.refreshToken);
+    return response.user;
+  }
+  /**
+   * Logout the current user.
+   *
+   * Invalidates tokens on the server and clears local token storage.
+   */
+  async logout() {
+    try {
+      await this.http.post("/api/v1/auth/logout");
+    } finally {
+      this.http.clearTokens();
+    }
+  }
+  /**
+   * Get the current authenticated user.
+   *
+   * @returns The current User
+   * @throws {AuthenticationError} If not authenticated
+   */
+  async me() {
+    return this.http.get("/api/v1/auth/me");
+  }
+  /**
+   * Manually refresh the access token.
+   *
+   * This is normally handled automatically when a request returns 401.
+   *
+   * @throws {AuthenticationError} If refresh token is invalid or expired
+   */
+  async refresh() {
+    const tokens = this.http.getTokens();
+    if (!tokens) {
+      throw new AuthenticationError("No refresh token available");
+    }
+    const response = await this.http.post(
+      "/api/v1/auth/refresh",
+      { refreshToken: tokens.refreshToken },
+      { includeAuth: false }
+    );
+    this.http.setTokens(response.accessToken, response.refreshToken);
+  }
+  /**
+   * Change the current user's password.
+   *
+   * @param currentPassword - Current password for verification
+   * @param newPassword - New password to set
+   * @throws {AuthenticationError} If current password is incorrect
+   * @throws {ValidationError} If new password doesn't meet requirements
+   */
+  async changePassword(currentPassword, newPassword) {
+    await this.http.put("/api/v1/auth/me/password", {
+      currentPassword,
+      newPassword
+    });
+  }
+  /**
+   * Get a satellite token for a specific audience (target service).
+   *
+   * Satellite tokens are short-lived, RS256-signed JWTs that allow satellite
+   * services (like SyftAI-Space) to verify user identity without calling
+   * SyftHub for every request.
+   *
+   * @param audience - Target service identifier (username of the service owner)
+   * @returns Satellite token response with token and expiry
+   * @throws {AuthenticationError} If not authenticated
+   * @throws {ValidationError} If audience is invalid or inactive
+   *
+   * @example
+   * // Get a token for querying alice's SyftAI-Space endpoints
+   * const tokenResponse = await client.auth.getSatelliteToken('alice');
+   * console.log(`Token expires in ${tokenResponse.expiresIn} seconds`);
+   */
+  async getSatelliteToken(audience) {
+    return this.http.get("/api/v1/token", { aud: audience });
+  }
+  /**
+   * Get satellite tokens for multiple audiences in parallel.
+   *
+   * This is useful when making requests to endpoints owned by different users.
+   * Tokens are cached and reused where possible.
+   *
+   * @param audiences - Array of unique audience identifiers (usernames)
+   * @returns Map of audience to satellite token
+   * @throws {AuthenticationError} If not authenticated
+   *
+   * @example
+   * // Get tokens for multiple endpoint owners
+   * const tokens = await client.auth.getSatelliteTokens(['alice', 'bob']);
+   * console.log(`Got ${tokens.size} tokens`);
+   */
+  async getSatelliteTokens(audiences) {
+    const uniqueAudiences = [...new Set(audiences)];
+    const tokenMap = /* @__PURE__ */ new Map();
+    const results = await Promise.allSettled(
+      uniqueAudiences.map(async (aud) => {
+        const response = await this.getSatelliteToken(aud);
+        return { audience: aud, token: response.targetToken };
+      })
+    );
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        tokenMap.set(result.value.audience, result.value.token);
+      }
+    }
+    return tokenMap;
+  }
+  /**
+   * Get transaction tokens for multiple endpoint owners.
+   *
+   * Transaction tokens are short-lived JWTs that pre-authorize the endpoint owner
+   * (recipient) to charge the current user (sender) for usage. These tokens are
+   * created via the accounting service and passed to the aggregator.
+   *
+   * This is used by the chat flow to enable billing for endpoint usage.
+   *
+   * @param ownerUsernames - Array of endpoint owner usernames
+   * @returns TransactionTokensResponse with tokens map and any errors
+   * @throws {AuthenticationError} If not authenticated
+   *
+   * @example
+   * // Get transaction tokens for endpoint owners
+   * const response = await client.auth.getTransactionTokens(['alice', 'bob']);
+   * console.log(`Got ${Object.keys(response.tokens).length} tokens`);
+   * if (Object.keys(response.errors).length > 0) {
+   *   console.log('Some tokens failed:', response.errors);
+   * }
+   */
+  async getTransactionTokens(ownerUsernames) {
+    const uniqueOwners = [...new Set(ownerUsernames)];
+    if (uniqueOwners.length === 0) {
+      return { tokens: {}, errors: {} };
+    }
+    try {
+      return await this.http.post(
+        "/api/v1/accounting/transaction-tokens",
+        { owner_usernames: uniqueOwners }
+      );
+    } catch (error) {
+      console.warn("Failed to get transaction tokens:", error);
+      return { tokens: {}, errors: {} };
+    }
+  }
+};
+
+// src/resources/users.ts
+var UsersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Update the current user's profile.
+   *
+   * Only provided fields will be updated.
+   *
+   * @param input - Fields to update
+   * @returns The updated User
+   * @throws {AuthenticationError} If not authenticated
+   * @throws {ValidationError} If input validation fails
+   */
+  async update(input) {
+    return this.http.put("/api/v1/users/me", input);
+  }
+  /**
+   * Check if a username is available.
+   *
+   * @param username - Username to check
+   * @returns True if the username is available
+   */
+  async checkUsername(username) {
+    const response = await this.http.get(
+      `/api/v1/users/check-username/${encodeURIComponent(username)}`,
+      void 0,
+      { includeAuth: false }
+    );
+    return response.available;
+  }
+  /**
+   * Check if an email is available.
+   *
+   * @param email - Email to check
+   * @returns True if the email is available
+   */
+  async checkEmail(email) {
+    const response = await this.http.get(
+      `/api/v1/users/check-email/${encodeURIComponent(email)}`,
+      void 0,
+      { includeAuth: false }
+    );
+    return response.available;
+  }
+  /**
+   * Get the current user's accounting service credentials.
+   *
+   * Returns credentials stored in SyftHub for connecting to an external
+   * accounting service. The email is always the same as the user's SyftHub email.
+   *
+   * @returns Accounting credentials (url and password may be null if not configured)
+   * @throws {AuthenticationError} If not authenticated
+   *
+   * @example
+   * const credentials = await client.users.getAccountingCredentials();
+   * if (credentials.url && credentials.password) {
+   *   // Use credentials to connect to accounting service
+   * }
+   */
+  async getAccountingCredentials() {
+    return this.http.get("/api/v1/users/me/accounting");
+  }
+};
+
+// src/pagination.ts
+var PageIterator = class {
+  /**
+   * Create a new PageIterator.
+   *
+   * @param fetcher - Function that fetches a page of items given skip and limit
+   * @param pageSize - Number of items to fetch per page (default: 20)
+   */
+  constructor(fetcher, pageSize = 20) {
+    this.fetcher = fetcher;
+    this.pageSize = pageSize;
+  }
+  items = [];
+  index = 0;
+  skip = 0;
+  exhausted = false;
+  initialized = false;
+  /**
+   * Async iterator implementation for `for await...of` loops.
+   */
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      if (this.index >= this.items.length) {
+        if (this.exhausted) break;
+        await this.fetchNextPage();
+        if (this.items.length === 0) break;
+      }
+      const item = this.items[this.index];
+      if (item === void 0) break;
+      this.index++;
+      yield item;
+    }
+  }
+  /**
+   * Get just the first page of results.
+   *
+   * @returns Promise resolving to the first page of items
+   */
+  async firstPage() {
+    if (!this.initialized) {
+      await this.fetchNextPage();
+    }
+    return [...this.items];
+  }
+  /**
+   * Get all items across all pages.
+   *
+   * Warning: This loads all items into memory. For large datasets,
+   * consider iterating with `for await...of` instead.
+   *
+   * @returns Promise resolving to all items
+   */
+  async all() {
+    const results = [];
+    for await (const item of this) {
+      results.push(item);
+    }
+    return results;
+  }
+  /**
+   * Get the first N items.
+   *
+   * @param n - Maximum number of items to return
+   * @returns Promise resolving to up to N items
+   */
+  async take(n) {
+    const results = [];
+    for await (const item of this) {
+      results.push(item);
+      if (results.length >= n) break;
+    }
+    return results;
+  }
+  /**
+   * Fetch the next page of items from the API.
+   */
+  async fetchNextPage() {
+    const page = await this.fetcher(this.skip, this.pageSize);
+    this.items = page;
+    this.index = 0;
+    this.skip += this.pageSize;
+    this.exhausted = page.length < this.pageSize;
+    this.initialized = true;
+  }
+};
+
+// src/resources/my-endpoints.ts
+var MyEndpointsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Parse an endpoint path into owner and slug.
+   *
+   * @param path - Path in "owner/slug" format
+   * @returns Tuple of [owner, slug]
+   * @throws {Error} If path format is invalid
+   */
+  parsePath(path) {
+    const parts = path.replace(/^\/|\/$/g, "").split("/");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+      throw new Error(`Invalid endpoint path: '${path}'. Expected format: 'owner/slug'`);
+    }
+    return [parts[0], parts[1]];
+  }
+  /**
+   * Resolve an endpoint path to its ID.
+   *
+   * @param path - Endpoint path in "owner/slug" format
+   * @returns The endpoint ID
+   */
+  async resolveEndpointId(path) {
+    const [owner, slug] = this.parsePath(path);
+    const response = await this.http.get(`/${owner}/${slug}`);
+    if (response.id === void 0) {
+      throw new Error(
+        `Could not resolve endpoint ID for '${path}'. Make sure you own this endpoint.`
+      );
+    }
+    return response.id;
+  }
+  /**
+   * List the current user's endpoints.
+   *
+   * @param options - Filtering and pagination options
+   * @returns PageIterator that lazily fetches endpoints
+   * @throws {AuthenticationError} If not authenticated
+   */
+  list(options) {
+    const pageSize = options?.pageSize ?? 20;
+    return new PageIterator(async (skip, limit) => {
+      const params = { skip, limit };
+      if (options?.visibility) {
+        params["visibility"] = options.visibility;
+      }
+      return this.http.get("/api/v1/endpoints", params);
+    }, pageSize);
+  }
+  /**
+   * Create a new endpoint.
+   *
+   * @param input - Endpoint creation details
+   * @param organizationId - Optional organization ID (for org-owned endpoints)
+   * @returns The created Endpoint
+   * @throws {AuthenticationError} If not authenticated
+   * @throws {ValidationError} If input validation fails
+   */
+  async create(input, organizationId) {
+    const body = organizationId !== void 0 ? { ...input, organizationId } : input;
+    return this.http.post("/api/v1/endpoints", body);
+  }
+  /**
+   * Get a specific endpoint by path.
+   *
+   * @param path - Endpoint path in "owner/slug" format (e.g., "alice/my-api")
+   * @returns The Endpoint
+   * @throws {AuthenticationError} If not authenticated
+   * @throws {NotFoundError} If endpoint not found
+   * @throws {AuthorizationError} If not authorized to view
+   */
+  async get(path) {
+    const [owner, slug] = this.parsePath(path);
+    return this.http.get(`/${owner}/${slug}`);
+  }
+  /**
+   * Update an endpoint.
+   *
+   * Only provided fields will be updated.
+   *
+   * @param path - Endpoint path in "owner/slug" format
+   * @param input - Fields to update
+   * @returns The updated Endpoint
+   * @throws {AuthenticationError} If not authenticated
+   * @throws {NotFoundError} If endpoint not found
+   * @throws {AuthorizationError} If not owner/admin
+   */
+  async update(path, input) {
+    const endpointId = await this.resolveEndpointId(path);
+    return this.http.patch(`/api/v1/endpoints/${endpointId}`, input);
+  }
+  /**
+   * Delete an endpoint.
+   *
+   * @param path - Endpoint path in "owner/slug" format
+   * @throws {AuthenticationError} If not authenticated
+   * @throws {NotFoundError} If endpoint not found
+   * @throws {AuthorizationError} If not owner/admin
+   */
+  async delete(path) {
+    const endpointId = await this.resolveEndpointId(path);
+    await this.http.delete(`/api/v1/endpoints/${endpointId}`);
+  }
+};
+
+// src/resources/hub.ts
+var HubResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Parse an endpoint path into owner and slug.
+   *
+   * @param path - Path in "owner/slug" format
+   * @returns Tuple of [owner, slug]
+   */
+  parsePath(path) {
+    const parts = path.replace(/^\/|\/$/g, "").split("/");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+      throw new Error(`Invalid endpoint path: '${path}'. Expected format: 'owner/slug'`);
+    }
+    return [parts[0], parts[1]];
+  }
+  /**
+   * Resolve an endpoint path to its ID.
+   *
+   * This searches the user's own endpoints to find the ID.
+   *
+   * @param path - Endpoint path in "owner/slug" format
+   * @returns The endpoint ID
+   */
+  async resolveEndpointId(path) {
+    const [, slug] = this.parsePath(path);
+    const endpoints = await this.http.get(
+      "/api/v1/endpoints",
+      { limit: 100 }
+    );
+    for (const ep of endpoints) {
+      if (ep.slug === slug && ep.id !== void 0) {
+        return ep.id;
+      }
+    }
+    const { NotFoundError: NotFoundError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+    throw new NotFoundError2(
+      `Could not resolve endpoint ID for '${path}'. Endpoint not found or you don't have access to get its ID.`
+    );
+  }
+  /**
+   * Browse all public endpoints.
+   *
+   * @param options - Pagination options
+   * @returns PageIterator that lazily fetches endpoints
+   */
+  browse(options) {
+    const pageSize = options?.pageSize ?? 20;
+    return new PageIterator(async (skip, limit) => {
+      return this.http.get(
+        "/api/v1/endpoints/public",
+        { skip, limit },
+        { includeAuth: false }
+      );
+    }, pageSize);
+  }
+  /**
+   * Get trending endpoints sorted by stars.
+   *
+   * @param options - Filter and pagination options
+   * @returns PageIterator that lazily fetches endpoints
+   */
+  trending(options) {
+    const pageSize = options?.pageSize ?? 20;
+    return new PageIterator(async (skip, limit) => {
+      const params = { skip, limit };
+      if (options?.minStars !== void 0) {
+        params["minStars"] = options.minStars;
+      }
+      return this.http.get(
+        "/api/v1/endpoints/trending",
+        params,
+        { includeAuth: false }
+      );
+    }, pageSize);
+  }
+  /**
+   * Get an endpoint by its path.
+   *
+   * This method searches the public endpoints API to find the endpoint,
+   * which works reliably across all deployment configurations.
+   *
+   * @param path - Endpoint path in "owner/slug" format (e.g., "alice/cool-api")
+   * @returns The EndpointPublic
+   * @throws {NotFoundError} If endpoint not found
+   */
+  async get(path) {
+    const [owner, slug] = this.parsePath(path);
+    for await (const endpoint of this.browse({ pageSize: 100 })) {
+      if (endpoint.ownerUsername === owner && endpoint.slug === slug) {
+        return endpoint;
+      }
+    }
+    const { NotFoundError: NotFoundError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+    throw new NotFoundError2(
+      `Endpoint not found: '${path}'. No public endpoint found with owner '${owner}' and slug '${slug}'.`
+    );
+  }
+  /**
+   * Star an endpoint.
+   *
+   * @param path - Endpoint path in "owner/slug" format
+   * @throws {AuthenticationError} If not authenticated
+   * @throws {NotFoundError} If endpoint not found
+   */
+  async star(path) {
+    const endpointId = await this.resolveEndpointId(path);
+    await this.http.patch(`/api/v1/endpoints/${endpointId}/star`);
+  }
+  /**
+   * Unstar an endpoint.
+   *
+   * @param path - Endpoint path in "owner/slug" format
+   * @throws {AuthenticationError} If not authenticated
+   * @throws {NotFoundError} If endpoint not found
+   */
+  async unstar(path) {
+    const endpointId = await this.resolveEndpointId(path);
+    await this.http.patch(`/api/v1/endpoints/${endpointId}/unstar`);
+  }
+  /**
+   * Check if you have starred an endpoint.
+   *
+   * @param path - Endpoint path in "owner/slug" format
+   * @returns True if starred, False otherwise
+   * @throws {AuthenticationError} If not authenticated
+   * @throws {NotFoundError} If endpoint not found
+   */
+  async isStarred(path) {
+    const endpointId = await this.resolveEndpointId(path);
+    const response = await this.http.get(
+      `/api/v1/endpoints/${endpointId}/starred`
+    );
+    return response.starred ?? false;
+  }
+};
+
+// src/models/common.ts
+var Visibility = {
+  /** Visible to everyone, no authentication required */
+  PUBLIC: "public",
+  /** Only visible to the owner and collaborators */
+  PRIVATE: "private",
+  /** Visible to authenticated users within the organization */
+  INTERNAL: "internal"
+};
+var EndpointType = {
+  /** Machine learning model endpoint */
+  MODEL: "model",
+  /** Data source endpoint */
+  DATA_SOURCE: "data_source"
+};
+var UserRole = {
+  /** Administrator with full access */
+  ADMIN: "admin",
+  /** Regular user */
+  USER: "user",
+  /** Guest user with limited access */
+  GUEST: "guest"
+};
+var OrganizationRole = {
+  /** Organization owner with full control */
+  OWNER: "owner",
+  /** Administrator with management privileges */
+  ADMIN: "admin",
+  /** Regular member */
+  MEMBER: "member"
+};
+
+// src/models/endpoint.ts
+function getEndpointOwnerType(endpoint) {
+  return endpoint.organizationId !== null ? "organization" : "user";
+}
+function getEndpointPublicPath(endpoint) {
+  return `${endpoint.ownerUsername}/${endpoint.slug}`;
+}
+
+// src/models/accounting.ts
+var TransactionStatus = {
+  /** Transaction created, awaiting confirmation */
+  PENDING: "pending",
+  /** Transaction confirmed, funds transferred */
+  COMPLETED: "completed",
+  /** Transaction cancelled, no funds transferred */
+  CANCELLED: "cancelled"
+};
+var CreatorType = {
+  /** System-initiated transaction */
+  SYSTEM: "system",
+  /** Sender-initiated transaction */
+  SENDER: "sender",
+  /** Recipient-initiated transaction (delegated) */
+  RECIPIENT: "recipient"
+};
+function parseTransaction(response) {
+  return {
+    ...response,
+    createdAt: new Date(response.createdAt),
+    resolvedAt: response.resolvedAt ? new Date(response.resolvedAt) : null
+  };
+}
+function isTransactionPending(tx) {
+  return tx.status === TransactionStatus.PENDING;
+}
+function isTransactionCompleted(tx) {
+  return tx.status === TransactionStatus.COMPLETED;
+}
+function isTransactionCancelled(tx) {
+  return tx.status === TransactionStatus.CANCELLED;
+}
+
+// src/resources/accounting.ts
+init_errors();
+async function handleResponseError(response) {
+  if (response.ok) return;
+  let detail;
+  try {
+    const body = await response.json();
+    detail = body.detail ?? body.message ?? JSON.stringify(body);
+  } catch {
+    detail = await response.text() || `HTTP ${response.status}`;
+  }
+  switch (response.status) {
+    case 401:
+      throw new AuthenticationError(`Authentication failed: ${detail}`);
+    case 403:
+      throw new AuthorizationError(`Permission denied: ${detail}`);
+    case 404:
+      throw new NotFoundError(`Not found: ${detail}`);
+    case 422:
+      throw new ValidationError(`Validation error: ${detail}`);
+    default:
+      throw new APIError(`Accounting API error: ${detail}`, response.status);
+  }
+}
+function createBasicAuth(email, password) {
+  const credentials = `${email}:${password}`;
+  const encoded = typeof btoa !== "undefined" ? btoa(credentials) : Buffer.from(credentials).toString("base64");
+  return `Basic ${encoded}`;
+}
+var AccountingResource = class {
+  baseUrl;
+  email;
+  password;
+  timeout;
+  authHeader;
+  constructor(options) {
+    this.baseUrl = options.url.replace(/\/$/, "");
+    this.email = options.email;
+    this.password = options.password;
+    this.timeout = options.timeout ?? 3e4;
+    this.authHeader = createBasicAuth(this.email, this.password);
+  }
+  // ===========================================================================
+  // Private HTTP Methods
+  // ===========================================================================
+  /**
+   * Make an authenticated request to the accounting service.
+   */
+  async request(method, path, options) {
+    const url = new URL(path, this.baseUrl);
+    if (options?.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url.toString(), {
+        method,
+        headers: {
+          "Authorization": this.authHeader,
+          "Content-Type": "application/json",
+          "Accept": "application/json"
+        },
+        body: options?.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      await handleResponseError(response);
+      if (response.status === 204) {
+        return {};
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof SyftHubError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new APIError("Request timeout", 408);
+      }
+      throw new APIError(`Accounting request failed: ${error instanceof Error ? error.message : "Unknown error"}`, 0);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Make a request using Bearer token auth (for delegated transactions).
+   */
+  async requestWithToken(method, path, token, options) {
+    const url = new URL(path, this.baseUrl);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url.toString(), {
+        method,
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Content-Type": "application/json",
+          "Accept": "application/json"
+        },
+        body: options?.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      await handleResponseError(response);
+      if (response.status === 204) {
+        return {};
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof SyftHubError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new APIError("Request timeout", 408);
+      }
+      throw new APIError(`Accounting request failed: ${error instanceof Error ? error.message : "Unknown error"}`, 0);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  // ===========================================================================
+  // User Operations
+  // ===========================================================================
+  /**
+   * Get the current user's account information including balance.
+   *
+   * @returns AccountingUser with id, email, balance, and organization
+   * @throws {AuthenticationError} If authentication fails
+   * @throws {APIError} On other errors
+   *
+   * @example
+   * ```typescript
+   * const user = await accounting.getUser();
+   * console.log(`Balance: ${user.balance}`);
+   * console.log(`Organization: ${user.organization}`);
+   * ```
+   */
+  async getUser() {
+    return this.request("GET", "/user");
+  }
+  /**
+   * Update the user's password.
+   *
+   * @param currentPassword - Current password for verification
+   * @param newPassword - New password to set
+   * @throws {AuthenticationError} If current password is wrong
+   * @throws {ValidationError} If new password doesn't meet requirements
+   *
+   * @example
+   * ```typescript
+   * await accounting.updatePassword('old_secret', 'new_secret');
+   * ```
+   */
+  async updatePassword(currentPassword, newPassword) {
+    await this.request("PUT", "/user/password", {
+      body: {
+        oldPassword: currentPassword,
+        newPassword
+      }
+    });
+  }
+  /**
+   * Update the user's organization.
+   *
+   * @param organization - New organization name
+   * @throws {AuthenticationError} If authentication fails
+   *
+   * @example
+   * ```typescript
+   * await accounting.updateOrganization('OpenMined');
+   * ```
+   */
+  async updateOrganization(organization) {
+    await this.request("PUT", "/user/organization", {
+      body: { organization }
+    });
+  }
+  // ===========================================================================
+  // Transaction Listing
+  // ===========================================================================
+  /**
+   * List account transactions with pagination.
+   *
+   * Returns a lazy iterator that fetches pages on demand.
+   *
+   * @param options - Pagination options
+   * @returns PageIterator that yields Transaction objects
+   *
+   * @example
+   * ```typescript
+   * // Iterate through all transactions
+   * for await (const tx of accounting.getTransactions()) {
+   *   console.log(`${tx.createdAt}: ${tx.amount} from ${tx.senderEmail}`);
+   * }
+   *
+   * // Get first page only
+   * const firstPage = await accounting.getTransactions().firstPage();
+   *
+   * // Get all transactions
+   * const allTxs = await accounting.getTransactions().all();
+   * ```
+   */
+  getTransactions(options) {
+    const pageSize = options?.pageSize ?? 20;
+    return new PageIterator(
+      async (skip, limit) => {
+        const response = await this.request("GET", "/transactions", {
+          params: { skip, limit }
+        });
+        return response.map(parseTransaction);
+      },
+      pageSize
+    );
+  }
+  /**
+   * Get a specific transaction by ID.
+   *
+   * @param transactionId - The transaction ID
+   * @returns Transaction object
+   * @throws {NotFoundError} If transaction not found
+   *
+   * @example
+   * ```typescript
+   * const tx = await accounting.getTransaction('tx_123');
+   * console.log(`Status: ${tx.status}`);
+   * ```
+   */
+  async getTransaction(transactionId) {
+    const response = await this.request(
+      "GET",
+      `/transactions/${transactionId}`
+    );
+    return parseTransaction(response);
+  }
+  // ===========================================================================
+  // Direct Transaction Operations
+  // ===========================================================================
+  /**
+   * Create a new transaction (direct transfer).
+   *
+   * Creates a PENDING transaction that must be confirmed or cancelled.
+   * The transaction is created by the sender (current user).
+   *
+   * @param input - Transaction details
+   * @returns Transaction in PENDING status
+   * @throws {ValidationError} If amount <= 0 or insufficient balance
+   *
+   * @example
+   * ```typescript
+   * const tx = await accounting.createTransaction({
+   *   recipientEmail: 'bob@example.com',
+   *   amount: 10.0,
+   *   appName: 'syftai-space',
+   *   appEpPath: 'alice/my-model'
+   * });
+   * console.log(`Created transaction ${tx.id}: ${tx.status}`);
+   *
+   * // Later, confirm or cancel
+   * await accounting.confirmTransaction(tx.id);
+   * ```
+   */
+  async createTransaction(input) {
+    if (input.amount <= 0) {
+      throw new ValidationError("Amount must be greater than 0");
+    }
+    const response = await this.request("POST", "/transactions", {
+      body: {
+        recipientEmail: input.recipientEmail,
+        amount: input.amount,
+        ...input.appName && { appName: input.appName },
+        ...input.appEpPath && { appEpPath: input.appEpPath }
+      }
+    });
+    return parseTransaction(response);
+  }
+  /**
+   * Confirm a pending transaction.
+   *
+   * Confirms the transaction, transferring funds from sender to recipient.
+   * Can be called by either the sender or recipient.
+   *
+   * @param transactionId - The transaction ID to confirm
+   * @returns Transaction in COMPLETED status
+   * @throws {NotFoundError} If transaction not found
+   * @throws {ValidationError} If transaction is not in PENDING status
+   *
+   * @example
+   * ```typescript
+   * const tx = await accounting.confirmTransaction('tx_123');
+   * console.log(`Confirmed: ${tx.status}`); // "completed"
+   * ```
+   */
+  async confirmTransaction(transactionId) {
+    const response = await this.request(
+      "POST",
+      `/transactions/${transactionId}/confirm`
+    );
+    return parseTransaction(response);
+  }
+  /**
+   * Cancel a pending transaction.
+   *
+   * Cancels the transaction without transferring funds.
+   * Can be called by either the sender or recipient.
+   *
+   * @param transactionId - The transaction ID to cancel
+   * @returns Transaction in CANCELLED status
+   * @throws {NotFoundError} If transaction not found
+   * @throws {ValidationError} If transaction is not in PENDING status
+   *
+   * @example
+   * ```typescript
+   * const tx = await accounting.cancelTransaction('tx_123');
+   * console.log(`Cancelled: ${tx.status}`); // "cancelled"
+   * ```
+   */
+  async cancelTransaction(transactionId) {
+    const response = await this.request(
+      "POST",
+      `/transactions/${transactionId}/cancel`
+    );
+    return parseTransaction(response);
+  }
+  // ===========================================================================
+  // Delegated Transaction Operations
+  // ===========================================================================
+  /**
+   * Create a transaction token for delegated transfers.
+   *
+   * Creates a JWT token that authorizes the recipient to create a
+   * transaction on behalf of the sender (current user). The token
+   * is short-lived (typically ~5 minutes).
+   *
+   * Use this when you want to pre-authorize a payment that will be
+   * initiated by the recipient (e.g., a service charging for usage).
+   *
+   * @param recipientEmail - Email of the authorized recipient
+   * @returns JWT token string to share with recipient
+   *
+   * @example
+   * ```typescript
+   * // Sender creates token
+   * const token = await accounting.createTransactionToken('service@example.com');
+   *
+   * // Share token with recipient out-of-band
+   * // Recipient uses token to create delegated transaction
+   * ```
+   */
+  async createTransactionToken(recipientEmail) {
+    const response = await this.request("POST", "/token/create", {
+      body: { recipientEmail }
+    });
+    return response.token;
+  }
+  /**
+   * Create a delegated transaction using a pre-authorized token.
+   *
+   * Creates a transaction on behalf of the sender using their token.
+   * This is typically used by services to charge users for usage.
+   *
+   * The token authenticates the request instead of Basic auth.
+   *
+   * @param senderEmail - Email of the sender who created the token
+   * @param amount - Amount to transfer (must be > 0)
+   * @param token - JWT token from sender's createTransactionToken()
+   * @returns Transaction in PENDING status (createdBy=RECIPIENT)
+   * @throws {AuthenticationError} If token is invalid or expired
+   * @throws {ValidationError} If amount <= 0
+   *
+   * @example
+   * ```typescript
+   * // Recipient creates transaction using sender's token
+   * const tx = await accounting.createDelegatedTransaction(
+   *   'alice@example.com',
+   *   5.0,
+   *   aliceToken
+   * );
+   *
+   * // Recipient confirms the transaction
+   * await accounting.confirmTransaction(tx.id);
+   * ```
+   */
+  async createDelegatedTransaction(senderEmail, amount, token) {
+    if (amount <= 0) {
+      throw new ValidationError("Amount must be greater than 0");
+    }
+    const response = await this.requestWithToken(
+      "POST",
+      "/transactions",
+      token,
+      {
+        body: {
+          senderEmail,
+          amount
+        }
+      }
+    );
+    return parseTransaction(response);
+  }
+};
+function createAccountingResource(options) {
+  return new AccountingResource(options);
+}
+
+// src/resources/chat.ts
+init_errors();
+var AggregatorError = class extends SyftHubError {
+  constructor(message, status, detail) {
+    super(message);
+    this.status = status;
+    this.detail = detail;
+    this.name = "AggregatorError";
+  }
+};
+var EndpointResolutionError = class extends SyftHubError {
+  constructor(message, endpointPath) {
+    super(message);
+    this.endpointPath = endpointPath;
+    this.name = "EndpointResolutionError";
+  }
+};
+var ChatResource = class {
+  constructor(hub, auth, aggregatorUrl) {
+    this.hub = hub;
+    this.auth = auth;
+    this.aggregatorUrl = aggregatorUrl;
+  }
+  /**
+   * Convert any endpoint format to EndpointRef with URL and owner info.
+   * The ownerUsername is critical for satellite token authentication.
+   */
+  async resolveEndpointRef(endpoint, expectedType) {
+    if (this.isEndpointRef(endpoint)) {
+      return endpoint;
+    }
+    if (this.isEndpointPublic(endpoint)) {
+      if (expectedType && endpoint.type !== expectedType) {
+        throw new Error(
+          `Expected endpoint type '${expectedType}', got '${endpoint.type}' for '${endpoint.slug}'`
+        );
+      }
+      for (const conn of endpoint.connect) {
+        if (conn.enabled && conn.config["url"]) {
+          return {
+            url: String(conn.config["url"]),
+            slug: endpoint.slug,
+            name: endpoint.name,
+            tenantName: conn.config["tenant_name"],
+            ownerUsername: endpoint.ownerUsername
+            // Capture owner for satellite token
+          };
+        }
+      }
+      throw new EndpointResolutionError(
+        `Endpoint '${endpoint.slug}' has no connection with URL configured`,
+        `${endpoint.ownerUsername}/${endpoint.slug}`
+      );
+    }
+    if (typeof endpoint === "string") {
+      let ep;
+      try {
+        ep = await this.hub.get(endpoint);
+      } catch (error) {
+        throw new EndpointResolutionError(
+          `Failed to fetch endpoint '${endpoint}': ${error instanceof Error ? error.message : String(error)}`,
+          endpoint
+        );
+      }
+      return this.resolveEndpointRef(ep, expectedType);
+    }
+    throw new TypeError(`Cannot resolve endpoint from type: ${typeof endpoint}`);
+  }
+  /**
+   * Collect unique owner usernames from all endpoints.
+   * Used to determine which satellite tokens need to be fetched.
+   */
+  collectUniqueOwners(modelRef, dataSourceRefs) {
+    const owners = /* @__PURE__ */ new Set();
+    if (modelRef.ownerUsername) {
+      owners.add(modelRef.ownerUsername);
+    }
+    for (const ds of dataSourceRefs) {
+      if (ds.ownerUsername) {
+        owners.add(ds.ownerUsername);
+      }
+    }
+    return [...owners];
+  }
+  /**
+   * Get satellite tokens for all unique endpoint owners.
+   * Returns a map of owner username to satellite token.
+   */
+  async getSatelliteTokensForOwners(owners) {
+    if (owners.length === 0) {
+      return {};
+    }
+    const tokenMap = await this.auth.getSatelliteTokens(owners);
+    const result = {};
+    for (const [owner, token] of tokenMap) {
+      result[owner] = token;
+    }
+    return result;
+  }
+  /**
+   * Get transaction tokens for all unique endpoint owners.
+   * Returns a map of owner username to transaction token.
+   *
+   * Transaction tokens are used for billing - they authorize the endpoint
+   * owner to charge the current user for usage.
+   */
+  async getTransactionTokensForOwners(owners) {
+    if (owners.length === 0) {
+      return {};
+    }
+    const response = await this.auth.getTransactionTokens(owners);
+    return response.tokens;
+  }
+  /**
+   * Type guard for EndpointRef.
+   */
+  isEndpointRef(value) {
+    return typeof value === "object" && value !== null && "url" in value && "slug" in value && typeof value.url === "string" && typeof value.slug === "string";
+  }
+  /**
+   * Type guard for EndpointPublic.
+   */
+  isEndpointPublic(value) {
+    return typeof value === "object" && value !== null && "connect" in value && "ownerUsername" in value && Array.isArray(value.connect);
+  }
+  /**
+   * Build the request body for the aggregator.
+   * Includes endpoint_tokens mapping for satellite token authentication.
+   * Includes transaction_tokens mapping for billing authorization.
+   * User identity is derived from satellite tokens, not passed in request body.
+   */
+  buildRequestBody(prompt, modelRef, dataSourceRefs, endpointTokens, transactionTokens, options) {
+    return {
+      prompt,
+      model: {
+        url: modelRef.url,
+        slug: modelRef.slug,
+        name: modelRef.name ?? "",
+        tenant_name: modelRef.tenantName ?? null,
+        owner_username: modelRef.ownerUsername ?? null
+      },
+      data_sources: dataSourceRefs.map((ds) => ({
+        url: ds.url,
+        slug: ds.slug,
+        name: ds.name ?? "",
+        tenant_name: ds.tenantName ?? null,
+        owner_username: ds.ownerUsername ?? null
+      })),
+      endpoint_tokens: endpointTokens,
+      transaction_tokens: transactionTokens,
+      top_k: options.topK ?? 5,
+      max_tokens: options.maxTokens ?? 1024,
+      temperature: options.temperature ?? 0.7,
+      similarity_threshold: options.similarityThreshold ?? 0.5,
+      stream: options.stream ?? false
+    };
+  }
+  /**
+   * Parse a SourceInfo from raw data.
+   */
+  parseSourceInfo(data) {
+    return {
+      path: String(data["path"] ?? ""),
+      documentsRetrieved: Number(data["documents_retrieved"] ?? 0),
+      status: data["status"] ?? "success",
+      errorMessage: data["error_message"]
+    };
+  }
+  /**
+   * Parse ChatMetadata from raw data.
+   */
+  parseMetadata(data) {
+    return {
+      retrievalTimeMs: Number(data["retrieval_time_ms"] ?? 0),
+      generationTimeMs: Number(data["generation_time_ms"] ?? 0),
+      totalTimeMs: Number(data["total_time_ms"] ?? 0)
+    };
+  }
+  /**
+   * Parse TokenUsage from raw data.
+   */
+  parseUsage(data) {
+    return {
+      promptTokens: Number(data["prompt_tokens"] ?? 0),
+      completionTokens: Number(data["completion_tokens"] ?? 0),
+      totalTokens: Number(data["total_tokens"] ?? 0)
+    };
+  }
+  /**
+   * Parse document sources from raw data.
+   * The new format is a dict mapping document title to {slug, content}.
+   */
+  parseDocumentSources(data) {
+    const sources = {};
+    if (!data || typeof data !== "object") {
+      return sources;
+    }
+    for (const [title, value] of Object.entries(data)) {
+      if (value && typeof value === "object") {
+        const source = value;
+        sources[title] = {
+          slug: String(source["slug"] ?? ""),
+          content: String(source["content"] ?? "")
+        };
+      }
+    }
+    return sources;
+  }
+  /**
+   * Parse retrieval info (SourceInfo array) from raw data.
+   */
+  parseRetrievalInfo(data) {
+    const retrievalInfo = [];
+    if (!Array.isArray(data)) {
+      return retrievalInfo;
+    }
+    for (const item of data) {
+      retrievalInfo.push(this.parseSourceInfo(item));
+    }
+    return retrievalInfo;
+  }
+  /**
+   * Send a chat request and get the complete response.
+   *
+   * This method automatically:
+   * 1. Resolves endpoints and extracts owner information
+   * 2. Exchanges Hub tokens for satellite tokens (one per unique owner)
+   * 3. Fetches transaction tokens for billing authorization
+   * 4. Sends tokens to the aggregator for forwarding to SyftAI-Space
+   *
+   * @param options - Chat completion options
+   * @returns ChatResponse with response text, sources, and metadata
+   * @throws {EndpointResolutionError} If endpoint cannot be resolved
+   * @throws {AggregatorError} If aggregator service fails
+   */
+  async complete(options) {
+    const modelRef = await this.resolveEndpointRef(options.model, "model");
+    const dsRefs = [];
+    for (const ds of options.dataSources ?? []) {
+      dsRefs.push(await this.resolveEndpointRef(ds, "data_source"));
+    }
+    const uniqueOwners = this.collectUniqueOwners(modelRef, dsRefs);
+    const endpointTokens = await this.getSatelliteTokensForOwners(uniqueOwners);
+    const transactionTokens = await this.getTransactionTokensForOwners(uniqueOwners);
+    const requestBody = this.buildRequestBody(
+      options.prompt,
+      modelRef,
+      dsRefs,
+      endpointTokens,
+      transactionTokens,
+      {
+        topK: options.topK,
+        maxTokens: options.maxTokens,
+        temperature: options.temperature,
+        similarityThreshold: options.similarityThreshold,
+        stream: false
+      }
+    );
+    const url = `${this.aggregatorUrl}/chat`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      let message = `HTTP ${response.status}`;
+      try {
+        const data2 = await response.json();
+        message = String(data2["message"] ?? data2["error"] ?? message);
+      } catch {
+      }
+      throw new AggregatorError(`Aggregator error: ${message}`, response.status);
+    }
+    const data = await response.json();
+    const sourcesData = data["sources"];
+    const sources = this.parseDocumentSources(sourcesData);
+    const retrievalInfoData = data["retrieval_info"];
+    const retrievalInfo = this.parseRetrievalInfo(retrievalInfoData);
+    const metadataData = data["metadata"];
+    const metadata = this.parseMetadata(metadataData ?? {});
+    const usageData = data["usage"];
+    const usage = usageData ? this.parseUsage(usageData) : void 0;
+    return {
+      response: String(data["response"] ?? ""),
+      sources,
+      retrievalInfo,
+      metadata,
+      usage
+    };
+  }
+  /**
+   * Send a chat request and stream response events.
+   *
+   * This method automatically:
+   * 1. Resolves endpoints and extracts owner information
+   * 2. Exchanges Hub tokens for satellite tokens (one per unique owner)
+   * 3. Fetches transaction tokens for billing authorization
+   * 4. Sends tokens to the aggregator for forwarding to SyftAI-Space
+   *
+   * @param options - Chat completion options
+   * @yields ChatStreamEvent objects as they arrive
+   */
+  async *stream(options) {
+    const modelRef = await this.resolveEndpointRef(options.model, "model");
+    const dsRefs = [];
+    for (const ds of options.dataSources ?? []) {
+      dsRefs.push(await this.resolveEndpointRef(ds, "data_source"));
+    }
+    const uniqueOwners = this.collectUniqueOwners(modelRef, dsRefs);
+    const endpointTokens = await this.getSatelliteTokensForOwners(uniqueOwners);
+    const transactionTokens = await this.getTransactionTokensForOwners(uniqueOwners);
+    const requestBody = this.buildRequestBody(
+      options.prompt,
+      modelRef,
+      dsRefs,
+      endpointTokens,
+      transactionTokens,
+      {
+        topK: options.topK,
+        maxTokens: options.maxTokens,
+        temperature: options.temperature,
+        similarityThreshold: options.similarityThreshold,
+        stream: true
+      }
+    );
+    const url = `${this.aggregatorUrl}/chat/stream`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
+      },
+      body: JSON.stringify(requestBody),
+      signal: options.signal
+    });
+    if (!response.ok) {
+      let message = `HTTP ${response.status}`;
+      try {
+        const data = await response.json();
+        message = String(data["message"] ?? data["error"] ?? message);
+      } catch {
+      }
+      throw new AggregatorError(`Aggregator error: ${message}`, response.status);
+    }
+    if (!response.body) {
+      throw new AggregatorError("No response body from aggregator");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentEvent = null;
+    let currentData = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmedLine = line.trim();
+          if (!trimmedLine) {
+            if (currentEvent && currentData) {
+              try {
+                const data = JSON.parse(currentData);
+                const event = this.parseSSEEvent(currentEvent, data);
+                if (event) {
+                  yield event;
+                }
+              } catch {
+              }
+            }
+            currentEvent = null;
+            currentData = "";
+            continue;
+          }
+          if (trimmedLine.startsWith("event:")) {
+            currentEvent = trimmedLine.slice(6).trim();
+          } else if (trimmedLine.startsWith("data:")) {
+            currentData = trimmedLine.slice(5).trim();
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Parse an SSE event into a typed event object.
+   */
+  parseSSEEvent(eventType, data) {
+    switch (eventType) {
+      case "retrieval_start":
+        return {
+          type: "retrieval_start",
+          sourceCount: Number(data["sources"] ?? 0)
+        };
+      case "source_complete":
+        return {
+          type: "source_complete",
+          path: String(data["path"] ?? ""),
+          status: String(data["status"] ?? ""),
+          documentsRetrieved: Number(data["documents"] ?? 0)
+        };
+      case "retrieval_complete":
+        return {
+          type: "retrieval_complete",
+          totalDocuments: Number(data["total_documents"] ?? 0),
+          timeMs: Number(data["time_ms"] ?? 0)
+        };
+      case "generation_start":
+        return { type: "generation_start" };
+      case "token":
+        return {
+          type: "token",
+          content: String(data["content"] ?? "")
+        };
+      case "done": {
+        const sourcesData = data["sources"];
+        const sources = this.parseDocumentSources(sourcesData);
+        const retrievalInfoData = data["retrieval_info"];
+        const retrievalInfo = this.parseRetrievalInfo(retrievalInfoData);
+        const metadataData = data["metadata"];
+        const metadata = this.parseMetadata(metadataData ?? {});
+        const usageData = data["usage"];
+        const usage = usageData ? this.parseUsage(usageData) : void 0;
+        return { type: "done", sources, retrievalInfo, metadata, usage };
+      }
+      case "error":
+        return {
+          type: "error",
+          message: String(data["message"] ?? "Unknown error")
+        };
+      default:
+        return {
+          type: "error",
+          message: `Unknown event type: ${eventType}`
+        };
+    }
+  }
+  /**
+   * Get model endpoints that have connection URLs configured.
+   *
+   * @param limit - Maximum number of results (default: 20)
+   * @returns Array of EndpointPublic objects for models with URLs
+   */
+  async getAvailableModels(limit = 20) {
+    const results = [];
+    for await (const endpoint of this.hub.browse()) {
+      if (results.length >= limit) break;
+      if (endpoint.type !== EndpointType.MODEL) continue;
+      const hasUrl = endpoint.connect.some(
+        (conn) => conn.enabled && conn.config["url"]
+      );
+      if (hasUrl) {
+        results.push(endpoint);
+      }
+    }
+    return results;
+  }
+  /**
+   * Get data source endpoints that have connection URLs configured.
+   *
+   * @param limit - Maximum number of results (default: 20)
+   * @returns Array of EndpointPublic objects for data sources with URLs
+   */
+  async getAvailableDataSources(limit = 20) {
+    const results = [];
+    for await (const endpoint of this.hub.browse()) {
+      if (results.length >= limit) break;
+      if (endpoint.type !== EndpointType.DATA_SOURCE) continue;
+      const hasUrl = endpoint.connect.some(
+        (conn) => conn.enabled && conn.config["url"]
+      );
+      if (hasUrl) {
+        results.push(endpoint);
+      }
+    }
+    return results;
+  }
+};
+
+// src/resources/syftai.ts
+init_errors();
+var RetrievalError = class extends SyftHubError {
+  constructor(message, sourcePath, detail) {
+    super(message);
+    this.sourcePath = sourcePath;
+    this.detail = detail;
+    this.name = "RetrievalError";
+  }
+};
+var GenerationError = class extends SyftHubError {
+  constructor(message, modelSlug, detail) {
+    super(message);
+    this.modelSlug = modelSlug;
+    this.detail = detail;
+    this.name = "GenerationError";
+  }
+};
+var SyftAIResource = class {
+  // No dependencies - uses direct fetch to SyftAI-Space endpoints
+  /**
+   * Build headers for SyftAI-Space request.
+   */
+  buildHeaders(tenantName) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (tenantName) {
+      headers["X-Tenant-Name"] = tenantName;
+    }
+    return headers;
+  }
+  /**
+   * Query a data source endpoint directly.
+   *
+   * @param options - Query options
+   * @returns Array of Document objects
+   * @throws {RetrievalError} If the query fails
+   */
+  async queryDataSource(options) {
+    const { endpoint, query, userEmail, topK = 5, similarityThreshold = 0.5 } = options;
+    const url = `${endpoint.url.replace(/\/$/, "")}/api/v1/endpoints/${endpoint.slug}/query`;
+    const requestBody = {
+      user_email: userEmail,
+      messages: query,
+      // SyftAI-Space expects "messages" for query text
+      limit: topK,
+      similarity_threshold: similarityThreshold
+    };
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: this.buildHeaders(endpoint.tenantName),
+        body: JSON.stringify(requestBody)
+      });
+    } catch (error) {
+      throw new RetrievalError(
+        `Failed to connect to data source '${endpoint.slug}': ${error instanceof Error ? error.message : String(error)}`,
+        endpoint.slug,
+        error
+      );
+    }
+    if (!response.ok) {
+      let message = `HTTP ${response.status}`;
+      try {
+        const data2 = await response.json();
+        message = String(data2["detail"] ?? data2["message"] ?? message);
+      } catch {
+      }
+      throw new RetrievalError(`Data source query failed: ${message}`, endpoint.slug);
+    }
+    const data = await response.json();
+    const documents = [];
+    const docsData = data["documents"];
+    if (Array.isArray(docsData)) {
+      for (const doc of docsData) {
+        documents.push({
+          content: String(doc["content"] ?? ""),
+          score: Number(doc["score"] ?? 0),
+          metadata: doc["metadata"] ?? {}
+        });
+      }
+    }
+    return documents;
+  }
+  /**
+   * Query a model endpoint directly.
+   *
+   * @param options - Query options
+   * @returns Generated response text
+   * @throws {GenerationError} If generation fails
+   */
+  async queryModel(options) {
+    const { endpoint, messages, userEmail, maxTokens = 1024, temperature = 0.7 } = options;
+    const url = `${endpoint.url.replace(/\/$/, "")}/api/v1/endpoints/${endpoint.slug}/query`;
+    const requestBody = {
+      user_email: userEmail,
+      messages: messages.map((msg) => ({
+        role: msg.role,
+        content: msg.content
+      })),
+      max_tokens: maxTokens,
+      temperature,
+      stream: false
+    };
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: this.buildHeaders(endpoint.tenantName),
+        body: JSON.stringify(requestBody)
+      });
+    } catch (error) {
+      throw new GenerationError(
+        `Failed to connect to model '${endpoint.slug}': ${error instanceof Error ? error.message : String(error)}`,
+        endpoint.slug,
+        error
+      );
+    }
+    if (!response.ok) {
+      let message = `HTTP ${response.status}`;
+      try {
+        const data2 = await response.json();
+        message = String(data2["detail"] ?? data2["message"] ?? message);
+      } catch {
+      }
+      throw new GenerationError(`Model query failed: ${message}`, endpoint.slug);
+    }
+    const data = await response.json();
+    const messageData = data["message"];
+    return String(messageData?.["content"] ?? "");
+  }
+  /**
+   * Stream a model response directly.
+   *
+   * @param options - Query options
+   * @yields Response text chunks as they arrive
+   * @throws {GenerationError} If generation fails
+   */
+  async *queryModelStream(options) {
+    const { endpoint, messages, userEmail, maxTokens = 1024, temperature = 0.7 } = options;
+    const url = `${endpoint.url.replace(/\/$/, "")}/api/v1/endpoints/${endpoint.slug}/query`;
+    const requestBody = {
+      user_email: userEmail,
+      messages: messages.map((msg) => ({
+        role: msg.role,
+        content: msg.content
+      })),
+      max_tokens: maxTokens,
+      temperature,
+      stream: true
+    };
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          ...this.buildHeaders(endpoint.tenantName),
+          Accept: "text/event-stream"
+        },
+        body: JSON.stringify(requestBody)
+      });
+    } catch (error) {
+      throw new GenerationError(
+        `Failed to connect to model '${endpoint.slug}': ${error instanceof Error ? error.message : String(error)}`,
+        endpoint.slug,
+        error
+      );
+    }
+    if (!response.ok) {
+      let message = `HTTP ${response.status}`;
+      try {
+        const data = await response.json();
+        message = String(data["detail"] ?? data["message"] ?? message);
+      } catch {
+      }
+      throw new GenerationError(`Model stream failed: ${message}`, endpoint.slug);
+    }
+    if (!response.body) {
+      throw new GenerationError("No response body from model", endpoint.slug);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmedLine = line.trim();
+          if (!trimmedLine || trimmedLine.startsWith("event:")) {
+            continue;
+          }
+          if (trimmedLine.startsWith("data:")) {
+            const dataStr = trimmedLine.slice(5).trim();
+            if (dataStr === "[DONE]") {
+              return;
+            }
+            try {
+              const data = JSON.parse(dataStr);
+              if (typeof data["content"] === "string") {
+                yield data["content"];
+              } else if (Array.isArray(data["choices"])) {
+                for (const choice of data["choices"]) {
+                  const delta = choice["delta"];
+                  if (delta && typeof delta["content"] === "string") {
+                    yield delta["content"];
+                  }
+                }
+              }
+            } catch {
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+
+// src/client.ts
+function getEnv(key) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[key];
+  }
+  return void 0;
+}
+function isBrowser() {
+  return typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined";
+}
+var SyftHubClient = class {
+  http;
+  options;
+  aggregatorUrl;
+  // Lazy-initialized resources
+  _auth;
+  _users;
+  _myEndpoints;
+  _hub;
+  _accounting;
+  _chat;
+  _syftai;
+  /**
+   * Create a new SyftHub client.
+   *
+   * @param options - Configuration options
+   * @throws {SyftHubError} If baseUrl is not provided and SYFTHUB_URL is not set (in non-browser environments)
+   */
+  constructor(options = {}) {
+    this.options = options;
+    let baseUrl = options.baseUrl ?? getEnv("SYFTHUB_URL");
+    if (!baseUrl && !isBrowser()) {
+      throw new SyftHubError(
+        "baseUrl is required. Provide it in options or set the SYFTHUB_URL environment variable."
+      );
+    }
+    baseUrl = baseUrl ?? "";
+    const normalizedUrl = baseUrl ? baseUrl.replace(/\/+$/, "") : "";
+    this.http = new HTTPClient(normalizedUrl, options.timeout ?? 3e4);
+    this.aggregatorUrl = options.aggregatorUrl ?? getEnv("SYFTHUB_AGGREGATOR_URL") ?? `${normalizedUrl}/aggregator/api/v1`;
+  }
+  /**
+   * Authentication resource for login, register, and session management.
+   *
+   * @example
+   * const user = await client.auth.login('alice', 'password');
+   * await client.auth.logout();
+   */
+  get auth() {
+    if (!this._auth) {
+      this._auth = new AuthResource(this.http);
+    }
+    return this._auth;
+  }
+  /**
+   * Users resource for profile management.
+   *
+   * @example
+   * const user = await client.users.update({ fullName: 'Alice Smith' });
+   * const available = await client.users.checkUsername('newname');
+   */
+  get users() {
+    if (!this._users) {
+      this._users = new UsersResource(this.http);
+    }
+    return this._users;
+  }
+  /**
+   * My Endpoints resource for managing your own endpoints.
+   *
+   * @example
+   * const endpoints = await client.myEndpoints.list().all();
+   * const endpoint = await client.myEndpoints.create({ name: 'My API', type: 'model' });
+   */
+  get myEndpoints() {
+    if (!this._myEndpoints) {
+      this._myEndpoints = new MyEndpointsResource(this.http);
+    }
+    return this._myEndpoints;
+  }
+  /**
+   * Hub resource for browsing public endpoints.
+   *
+   * @example
+   * for await (const endpoint of client.hub.browse()) {
+   *   console.log(endpoint.name);
+   * }
+   */
+  get hub() {
+    if (!this._hub) {
+      this._hub = new HubResource(this.http);
+    }
+    return this._hub;
+  }
+  /**
+   * Accounting resource for billing and transactions.
+   *
+   * The accounting service is external and uses separate credentials
+   * (email/password Basic auth) from SyftHub's JWT authentication.
+   *
+   * Credentials can be provided via:
+   * - Constructor options: accountingUrl, accountingEmail, accountingPassword
+   * - Environment variables: SYFTHUB_ACCOUNTING_URL, SYFTHUB_ACCOUNTING_EMAIL, SYFTHUB_ACCOUNTING_PASSWORD
+   *
+   * @throws {SyftHubError} If accounting credentials are not configured
+   *
+   * @example
+   * const user = await client.accounting.getUser();
+   * console.log(`Balance: ${user.balance}`);
+   *
+   * // Create a transaction
+   * const tx = await client.accounting.createTransaction({
+   *   recipientEmail: 'bob@example.com',
+   *   amount: 10.0
+   * });
+   */
+  get accounting() {
+    if (!this._accounting) {
+      const url = this.options.accountingUrl ?? getEnv("SYFTHUB_ACCOUNTING_URL");
+      const email = this.options.accountingEmail ?? getEnv("SYFTHUB_ACCOUNTING_EMAIL");
+      const password = this.options.accountingPassword ?? getEnv("SYFTHUB_ACCOUNTING_PASSWORD");
+      if (!url || !email || !password) {
+        const missing = [];
+        if (!url) missing.push("SYFTHUB_ACCOUNTING_URL");
+        if (!email) missing.push("SYFTHUB_ACCOUNTING_EMAIL");
+        if (!password) missing.push("SYFTHUB_ACCOUNTING_PASSWORD");
+        throw new ConfigurationError(
+          `Accounting not configured. Missing: ${missing.join(", ")}. Set environment variables or pass credentials to SyftHubClient.`
+        );
+      }
+      this._accounting = new AccountingResource({
+        url,
+        email,
+        password,
+        timeout: this.options.timeout
+      });
+    }
+    return this._accounting;
+  }
+  /**
+   * Chat resource for RAG-augmented conversations via the Aggregator.
+   *
+   * This resource provides high-level chat functionality that integrates
+   * with the SyftHub Aggregator service for RAG workflows.
+   *
+   * @example
+   * // Simple chat completion
+   * const response = await client.chat.complete({
+   *   prompt: 'What is machine learning?',
+   *   model: 'alice/gpt-model',
+   *   dataSources: ['bob/ml-docs'],
+   * });
+   * console.log(response.response);
+   *
+   * // Streaming chat
+   * for await (const event of client.chat.stream(options)) {
+   *   if (event.type === 'token') {
+   *     process.stdout.write(event.content);
+   *   }
+   * }
+   *
+   * // Get available endpoints
+   * const models = await client.chat.getAvailableModels();
+   * const sources = await client.chat.getAvailableDataSources();
+   */
+  get chat() {
+    if (!this._chat) {
+      this._chat = new ChatResource(
+        this.hub,
+        this.auth,
+        this.aggregatorUrl
+      );
+    }
+    return this._chat;
+  }
+  /**
+   * SyftAI-Space resource for direct endpoint queries (low-level API).
+   *
+   * This resource provides direct access to SyftAI-Space endpoints without
+   * going through the aggregator. Use this when you need custom RAG pipelines
+   * or fine-grained control over queries.
+   *
+   * For most use cases, prefer the higher-level `client.chat` API instead.
+   *
+   * @example
+   * // Query a data source directly
+   * const docs = await client.syftai.queryDataSource({
+   *   endpoint: { url: 'http://syftai:8080', slug: 'docs' },
+   *   query: 'What is Python?',
+   *   userEmail: 'alice@example.com',
+   * });
+   *
+   * // Query a model directly
+   * const response = await client.syftai.queryModel({
+   *   endpoint: { url: 'http://syftai:8080', slug: 'gpt-model' },
+   *   messages: [{ role: 'user', content: 'Hello!' }],
+   *   userEmail: 'alice@example.com',
+   * });
+   */
+  get syftai() {
+    if (!this._syftai) {
+      this._syftai = new SyftAIResource();
+    }
+    return this._syftai;
+  }
+  /**
+   * Get current authentication tokens.
+   *
+   * Use this to persist tokens for later sessions.
+   *
+   * @returns Current tokens or null if not authenticated
+   *
+   * @example
+   * const tokens = client.getTokens();
+   * if (tokens) {
+   *   localStorage.setItem('tokens', JSON.stringify(tokens));
+   * }
+   */
+  getTokens() {
+    return this.http.getTokens();
+  }
+  /**
+   * Set authentication tokens.
+   *
+   * Use this to restore a session from previously saved tokens.
+   *
+   * @param tokens - Tokens to set
+   *
+   * @example
+   * const saved = JSON.parse(localStorage.getItem('tokens'));
+   * if (saved) {
+   *   client.setTokens(saved);
+   * }
+   */
+  setTokens(tokens) {
+    this.http.setTokens(tokens.accessToken, tokens.refreshToken);
+  }
+  /**
+   * Check if the client is currently authenticated.
+   *
+   * @returns True if tokens are present
+   */
+  get isAuthenticated() {
+    return this.http.hasTokens();
+  }
+  /**
+   * Check if accounting service is configured.
+   *
+   * Use this to check if accounting credentials are available before
+   * accessing the `accounting` property, which will throw if not configured.
+   *
+   * @returns True if accounting url, email, and password are all configured
+   *
+   * @example
+   * if (client.isAccountingConfigured) {
+   *   const user = await client.accounting.getUser();
+   * }
+   */
+  get isAccountingConfigured() {
+    const url = this.options.accountingUrl ?? getEnv("SYFTHUB_ACCOUNTING_URL");
+    const email = this.options.accountingEmail ?? getEnv("SYFTHUB_ACCOUNTING_EMAIL");
+    const password = this.options.accountingPassword ?? getEnv("SYFTHUB_ACCOUNTING_PASSWORD");
+    return Boolean(url && email && password);
+  }
+  /**
+   * Close the client and clean up resources.
+   *
+   * Currently a no-op, but may be used in future for connection pooling.
+   */
+  close() {
+  }
+};
+
+// src/index.ts
+init_errors();
+
+export { APIError, AccountingAccountExistsError, AccountingResource, AccountingServiceUnavailableError, AggregatorError, AuthenticationError, AuthorizationError, ChatResource, ConfigurationError, CreatorType, EndpointResolutionError, EndpointType, GenerationError, InvalidAccountingPasswordError, NetworkError, NotFoundError, OrganizationRole, PageIterator, RetrievalError, SyftAIResource, SyftHubClient, SyftHubError, TransactionStatus, UserAlreadyExistsError, UserRole, ValidationError, Visibility, createAccountingResource, getEndpointOwnerType, getEndpointPublicPath, isTransactionCancelled, isTransactionCompleted, isTransactionPending, parseTransaction };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map