@gpt-core/client 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/index.mjs

@@ -1354,9 +1354,131 @@ var EmbeddingService = class {
   }
 };
 
+// src/errors/index.ts
+var GptCoreError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = this.constructor.name;
+    this.statusCode = options?.statusCode;
+    this.code = options?.code;
+    this.requestId = options?.requestId;
+    this.headers = options?.headers;
+    this.body = options?.body;
+    if (options?.cause) {
+      this.cause = options.cause;
+    }
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var AuthenticationError = class extends GptCoreError {
+  constructor(message = "Authentication failed", options) {
+    super(message, { statusCode: 401, ...options });
+  }
+};
+var AuthorizationError = class extends GptCoreError {
+  constructor(message = "Permission denied", options) {
+    super(message, { statusCode: 403, ...options });
+  }
+};
+var NotFoundError = class extends GptCoreError {
+  constructor(message = "Resource not found", options) {
+    super(message, { statusCode: 404, ...options });
+  }
+};
+var ValidationError = class extends GptCoreError {
+  constructor(message = "Validation failed", errors, options) {
+    super(message, { statusCode: 422, ...options });
+    this.errors = errors;
+  }
+};
+var RateLimitError = class extends GptCoreError {
+  constructor(message = "Rate limit exceeded", retryAfter, options) {
+    super(message, { statusCode: 429, ...options });
+    this.retryAfter = retryAfter;
+  }
+};
+var NetworkError = class extends GptCoreError {
+  constructor(message = "Network request failed", options) {
+    super(message, options);
+  }
+};
+var TimeoutError = class extends GptCoreError {
+  constructor(message = "Request timeout", options) {
+    super(message, options);
+  }
+};
+var ServerError = class extends GptCoreError {
+  constructor(message = "Internal server error", options) {
+    super(message, { statusCode: 500, ...options });
+  }
+};
+function handleApiError(error) {
+  const response = error?.response || error;
+  const statusCode = response?.status || error?.status || error?.statusCode;
+  const headers = response?.headers || error?.headers;
+  const requestId = headers?.get?.("x-request-id") || headers?.["x-request-id"];
+  const body = response?.body || response?.data || error?.body || error?.data || error;
+  let message = "An error occurred";
+  let errors;
+  if (body?.errors && Array.isArray(body.errors)) {
+    const firstError = body.errors[0];
+    message = firstError?.title || firstError?.detail || message;
+    errors = body.errors.map((err) => ({
+      field: err.source?.pointer?.split("/").pop(),
+      message: err.detail || err.title || "Unknown error"
+    }));
+  } else if (body?.message) {
+    message = body.message;
+  } else if (typeof body === "string") {
+    message = body;
+  } else if (error?.message) {
+    message = error.message;
+  }
+  const errorOptions = {
+    statusCode,
+    requestId,
+    headers: headers ? headers.entries ? Object.fromEntries(headers.entries()) : Object.fromEntries(Object.entries(headers)) : void 0,
+    body,
+    cause: error
+  };
+  switch (statusCode) {
+    case 401:
+      throw new AuthenticationError(message, errorOptions);
+    case 403:
+      throw new AuthorizationError(message, errorOptions);
+    case 404:
+      throw new NotFoundError(message, errorOptions);
+    case 400:
+    case 422:
+      throw new ValidationError(message, errors, errorOptions);
+    case 429:
+      const retryAfter = headers?.get?.("retry-after") || headers?.["retry-after"];
+      throw new RateLimitError(message, retryAfter ? parseInt(retryAfter, 10) : void 0, errorOptions);
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      throw new ServerError(message, errorOptions);
+    default:
+      if (statusCode && statusCode >= 400) {
+        throw new GptCoreError(message, errorOptions);
+      }
+      throw new NetworkError(message, errorOptions);
+  }
+}
+
 // src/base-client.ts
 var BaseClient = class {
   constructor(config = {}) {
+    this.config = config;
+    this.retryConfig = config.retry !== void 0 ? config.retry : {
+      maxRetries: 3,
+      initialDelay: 1e3,
+      maxDelay: 32e3,
+      retryableStatusCodes: [429, 500, 502, 503, 504]
+    };
     if (config.baseUrl) {
       client.setConfig({ baseUrl: config.baseUrl });
     }
@@ -1371,6 +1493,12 @@ var BaseClient = class {
       }
       return req;
     });
+    client.interceptors.response.use((response) => {
+      if (response.error) {
+        handleApiError(response.error);
+      }
+      return response;
+    });
   }
   unwrap(resource) {
     if (!resource) return null;
@@ -1379,64 +1507,176 @@ var BaseClient = class {
     }
     return resource;
   }
+  handleError(error) {
+    return handleApiError(error);
+  }
 };
 
+// src/pagination.ts
+async function* paginateAll(fetcher, options = {}) {
+  const pageSize = options.pageSize || 20;
+  const limit = options.limit;
+  let page = 1;
+  let totalYielded = 0;
+  while (true) {
+    const response = await fetcher(page, pageSize);
+    for (const item of response.data) {
+      yield item;
+      totalYielded++;
+      if (limit && totalYielded >= limit) {
+        return;
+      }
+    }
+    if (!response.links?.next || response.data.length === 0) {
+      break;
+    }
+    page++;
+  }
+}
+async function paginateToArray(fetcher, options = {}) {
+  const results = [];
+  for await (const item of paginateAll(fetcher, options)) {
+    results.push(item);
+  }
+  return results;
+}
+
+// src/schemas/requests.ts
+import { z } from "zod";
+var LoginRequestSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8)
+});
+var RegisterRequestSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8),
+  password_confirmation: z.string().min(8)
+}).refine((data) => data.password === data.password_confirmation, {
+  message: "Passwords don't match",
+  path: ["password_confirmation"]
+});
+var ApiKeyCreateSchema = z.object({
+  name: z.string().min(1).max(255)
+});
+var ApiKeyAllocateSchema = z.object({
+  amount: z.number().positive(),
+  description: z.string().min(1)
+});
+var ApplicationCreateSchema = z.object({
+  name: z.string().min(1).max(255),
+  slug: z.string().regex(/^[a-z0-9-]+$/).optional(),
+  description: z.string().optional()
+});
+var WorkspaceCreateSchema = z.object({
+  name: z.string().min(1).max(255),
+  slug: z.string().regex(/^[a-z0-9-]+$/).optional()
+});
+var InvitationCreateSchema = z.object({
+  email: z.string().email(),
+  role: z.string(),
+  scope_type: z.enum(["tenant", "workspace"]),
+  scope_id: z.string().uuid()
+});
+var AgentCreateSchema = z.object({
+  name: z.string().min(1).max(255),
+  prompt_template: z.string().min(1)
+});
+var ThreadCreateSchema = z.object({
+  title: z.string().max(255).optional()
+});
+var MessageSendSchema = z.object({
+  content: z.string().min(1)
+});
+var SearchRequestSchema = z.object({
+  query: z.string().min(1),
+  top_k: z.number().int().positive().max(100).default(5)
+});
+var EmbedRequestSchema = z.object({
+  text: z.string().min(1),
+  workspace_id: z.string().uuid().optional()
+});
+var DocumentUploadBase64Schema = z.object({
+  filename: z.string().min(1),
+  content: z.string().min(1)
+  // base64 content
+});
+var BucketCreateSchema = z.object({
+  name: z.string().min(1).max(255),
+  type: z.enum(["public", "private"])
+});
+var PresignedUploadSchema = z.object({
+  filename: z.string().min(1),
+  content_type: z.string().min(1)
+});
+var PresignedDownloadSchema = z.object({
+  file_id: z.string().uuid()
+});
+
 // src/gpt-client.ts
 var GptClient = class extends BaseClient {
   constructor(config) {
     super(config);
     this.identity = {
       login: async (email, password) => {
+        const validated = LoginRequestSchema.parse({ email, password });
         const { data, error } = await UserService.postUsersAuthLogin({
-          body: { data: { type: "user", attributes: { email, password } } }
+          body: {
+            data: {
+              type: "user",
+              attributes: validated
+            }
+          }
         });
-        if (error) throw error;
+        if (error) this.handleError(error);
         return {
           user: this.unwrap(data?.data),
           token: data?.meta?.token
         };
       },
       register: async (email, password, password_confirmation) => {
+        const validated = RegisterRequestSchema.parse({ email, password, password_confirmation });
         const { data, error } = await UserService.postUsersAuthRegister({
           body: {
             data: {
               type: "user",
-              attributes: { email, password, password_confirmation }
+              attributes: validated
             }
           }
         });
-        if (error) throw error;
+        if (error) this.handleError(error);
         return this.unwrap(data?.data);
       },
       me: async () => {
         const { data, error } = await UserService.getUsersMe();
-        if (error) throw error;
+        if (error) this.handleError(error);
         return this.unwrap(data?.data);
       },
       profile: async () => {
         const { data, error } = await UserProfileService.getUserProfilesMe();
-        if (error) throw error;
+        if (error) this.handleError(error);
         return this.unwrap(data?.data);
       },
       apiKeys: {
         list: async () => {
           const { data, error } = await ApiKeyService.getApiKeys();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         create: async (name) => {
+          const validated = ApiKeyCreateSchema.parse({ name });
           const { data, error } = await ApiKeyService.postApiKeys({
-            body: { data: { type: "api_key", attributes: { name } } }
+            body: { data: { type: "api_key", attributes: validated } }
           });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         allocate: async (id, amount, description) => {
+          const validated = ApiKeyAllocateSchema.parse({ amount, description });
           const { error } = await ApiKeyService.patchApiKeysByIdAllocate({
             path: { id },
-            body: { data: { type: "api_key", id, attributes: { amount, description } } }
+            body: { data: { type: "api_key", id, attributes: validated } }
           });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return true;
         }
       }
@@ -1445,68 +1685,76 @@ var GptClient = class extends BaseClient {
       applications: {
         list: async () => {
           const { data, error } = await ApplicationService.getApplications();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         create: async (attributes) => {
+          const validated = ApplicationCreateSchema.parse(attributes);
           const { data, error } = await ApplicationService.postApplications({
-            body: { data: { type: "application", attributes } }
+            body: { data: { type: "application", attributes: validated } }
           });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         getBySlug: async (slug) => {
           const { data, error } = await ApplicationService.getApplicationsBySlugBySlug({
             path: { slug }
           });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         }
       },
       workspaces: {
         list: async () => {
           const { data, error } = await WorkspaceService.getWorkspaces();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         mine: async () => {
           const { data, error } = await WorkspaceService.getWorkspacesMine();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         create: async (name, slug) => {
+          const validated = WorkspaceCreateSchema.parse({ name, slug });
           const { data, error } = await WorkspaceService.postWorkspaces({
-            body: { data: { type: "workspace", attributes: { name, slug } } }
+            body: { data: { type: "workspace", attributes: validated } }
           });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         }
       },
       tenants: {
         list: async () => {
           const { data, error } = await TenantService.getTenants();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         }
       },
       invitations: {
         list: async () => {
           const { data, error } = await InvitationService.getInvitations();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         invite: async (email, role2, scopeType, scopeId) => {
+          const validated = InvitationCreateSchema.parse({
+            email,
+            role: role2,
+            scope_type: scopeType,
+            scope_id: scopeId
+          });
           const { error } = await InvitationService.postInvitationsInvite({
-            body: { email, role: role2, scope_type: scopeType, scope_id: scopeId }
+            body: validated
           });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return true;
         }
       },
       auditLogs: {
         list: async () => {
           const { data, error } = await AuditLogService.getAuditLogs();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         }
       }
@@ -1515,51 +1763,75 @@ var GptClient = class extends BaseClient {
       agents: {
         list: async () => {
           const { data, error } = await AgentService.getAgents();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         create: async (name, promptTemplate) => {
+          const validated = AgentCreateSchema.parse({ name, prompt_template: promptTemplate });
           const { data, error } = await AgentService.postAgents({
-            body: { data: { type: "agent", attributes: { name, prompt_template: promptTemplate } } }
+            body: { data: { type: "agent", attributes: validated } }
           });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         }
       },
       threads: {
         list: async () => {
           const { data, error } = await ThreadService.getThreads();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         create: async (title) => {
+          const validated = ThreadCreateSchema.parse({ title });
           const { data, error } = await ThreadService.postThreads({
-            body: { data: { type: "thread", attributes: { title } } }
+            body: { data: { type: "thread", attributes: validated } }
           });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         sendMessage: async (threadId, content) => {
+          const validated = MessageSendSchema.parse({ content });
           const { data, error } = await ThreadService.postThreadsByIdMessages({
             path: { id: threadId },
-            body: { data: { attributes: { content } } }
+            body: { data: { attributes: validated } }
           });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data);
         }
+        /**
+         * Note: For streaming message responses, use the streaming utilities:
+         *
+         * ```typescript
+         * import { streamMessage } from '@gpt-core/client';
+         *
+         * // Make streaming request to backend
+         * const response = await fetch(`${baseUrl}/threads/${threadId}/messages/stream`, {
+         *   method: 'POST',
+         *   headers: { 'Accept': 'text/event-stream' },
+         *   body: JSON.stringify({ content: 'Hello' })
+         * });
+         *
+         * // Stream the response
+         * for await (const chunk of streamMessage(response)) {
+         *   console.log(chunk.content);
+         * }
+         * ```
+         */
       },
       search: async (query, top_k = 5) => {
+        const validated = SearchRequestSchema.parse({ query, top_k });
         const { data, error } = await SearchService.postAiSearch({
-          body: { query, top_k }
+          body: validated
         });
-        if (error) throw error;
+        if (error) this.handleError(error);
         return this.unwrap(data);
       },
       embed: async (text, workspaceId) => {
+        const validated = EmbedRequestSchema.parse({ text, workspace_id: workspaceId });
         const { data, error } = await EmbeddingService.postAiEmbed({
-          body: { text, workspace_id: workspaceId }
+          body: validated
         });
-        if (error) throw error;
+        if (error) this.handleError(error);
         return this.unwrap(data);
       }
     };
@@ -1567,39 +1839,40 @@ var GptClient = class extends BaseClient {
       documents: {
         list: async () => {
           const { data, error } = await DocumentService.getDocuments();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         upload: async (_file, _filename) => {
           throw new Error("Use uploadBase64 for now");
         },
         uploadBase64: async (filename, base64Content) => {
+          const validated = DocumentUploadBase64Schema.parse({ filename, content: base64Content });
           const { data, error } = await DocumentService.postDocuments({
-            body: { data: { type: "document", attributes: { filename, content: base64Content } } }
+            body: { data: { type: "document", attributes: validated } }
           });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         get: async (id) => {
           const { data, error } = await DocumentService.getDocumentsById({ path: { id } });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         delete: async (id) => {
           const { error } = await DocumentService.deleteDocumentsById({ path: { id } });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return true;
         },
         analyze: async (id) => {
           const { error } = await DocumentService.postDocumentsByIdAnalyze({ path: { id }, body: {} });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return true;
         }
       },
       results: {
         list: async () => {
           const { data, error } = await ExtractionResultService.getExtractionResults();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         }
       }
@@ -1608,30 +1881,33 @@ var GptClient = class extends BaseClient {
       buckets: {
         list: async () => {
           const { data, error } = await BucketService.getBuckets();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         },
         create: async (name, isPublic = false) => {
+          const validated = BucketCreateSchema.parse({ name, type: isPublic ? "public" : "private" });
           const { data, error } = await BucketService.postBuckets({
-            body: { data: { type: "bucket", attributes: { name, type: isPublic ? "public" : "private" } } }
+            body: { data: { type: "bucket", attributes: validated } }
           });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         }
       },
       presigned: {
         upload: async (filename, contentType) => {
+          const validated = PresignedUploadSchema.parse({ filename, content_type: contentType });
           const { data, error } = await PresignedUrlService.postStorageSignUpload({
-            body: { filename, content_type: contentType }
+            body: validated
           });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data);
         },
         download: async (fileId) => {
+          const validated = PresignedDownloadSchema.parse({ file_id: fileId });
           const { data, error } = await PresignedUrlService.postStorageSignDownload({
-            body: { file_id: fileId }
+            body: validated
           });
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data);
         }
       }
@@ -1640,14 +1916,14 @@ var GptClient = class extends BaseClient {
       wallet: {
         get: async () => {
           const { data, error } = await WalletService.getWallet();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         }
       },
       plans: {
         list: async () => {
           const { data, error } = await PlanService.getPlans();
-          if (error) throw error;
+          if (error) this.handleError(error);
           return this.unwrap(data?.data);
         }
       }
@@ -1928,8 +2204,157 @@ var type = {
   PUBLIC: "public",
   PRIVATE: "private"
 };
+
+// src/utils/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelay: 1e3,
+  // 1 second
+  maxDelay: 32e3,
+  // 32 seconds
+  retryableStatusCodes: [429, 500, 502, 503, 504]
+};
+function isRetryableError(error, retryableStatusCodes) {
+  const statusCode = error?.status || error?.statusCode || error?.response?.status;
+  return retryableStatusCodes.includes(statusCode);
+}
+function calculateBackoff(attempt, initialDelay, maxDelay, retryAfter) {
+  if (retryAfter) {
+    return Math.min(retryAfter * 1e3, maxDelay);
+  }
+  const exponentialDelay = initialDelay * Math.pow(2, attempt);
+  const jitter = Math.random() * 0.3 * exponentialDelay;
+  const delay = exponentialDelay + jitter;
+  return Math.min(delay, maxDelay);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retryWithBackoff(fn, config = DEFAULT_RETRY_CONFIG) {
+  let lastError;
+  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === config.maxRetries || !isRetryableError(error, config.retryableStatusCodes)) {
+        throw error;
+      }
+      const errorWithHeaders = error;
+      const retryAfter = errorWithHeaders?.response?.headers?.get?.("retry-after") || errorWithHeaders?.response?.headers?.["retry-after"] || errorWithHeaders?.headers?.get?.("retry-after") || errorWithHeaders?.headers?.["retry-after"];
+      const retryAfterSeconds = retryAfter ? parseInt(retryAfter, 10) : void 0;
+      const delay = calculateBackoff(
+        attempt,
+        config.initialDelay,
+        config.maxDelay,
+        retryAfterSeconds
+      );
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+function withRetry(fn, config) {
+  const retryConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+  return async (...args) => {
+    return retryWithBackoff(() => fn(...args), retryConfig);
+  };
+}
+
+// src/streaming.ts
+async function* streamSSE(response, options = {}) {
+  if (!response.body) {
+    throw new Error("Response body is null");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (options.signal?.aborted) {
+        reader.cancel();
+        throw new Error("Stream aborted");
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          if (data === "[DONE]" || data.trim() === "") {
+            continue;
+          }
+          try {
+            const parsed = JSON.parse(data);
+            yield parsed;
+          } catch (e) {
+            yield data;
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (options.onError) {
+      options.onError(error);
+    }
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function* streamMessage(response, options = {}) {
+  for await (const chunk of streamSSE(response, options)) {
+    yield chunk;
+    if (chunk.type === "done" || chunk.type === "error") {
+      break;
+    }
+  }
+}
+async function collectStreamedMessage(stream) {
+  let fullMessage = "";
+  for await (const chunk of stream) {
+    if (chunk.type === "content" && chunk.content) {
+      fullMessage += chunk.content;
+    } else if (chunk.type === "error") {
+      throw new Error(chunk.error || "Stream error");
+    }
+  }
+  return fullMessage;
+}
 export {
+  AgentCreateSchema,
+  ApiKeyAllocateSchema,
+  ApiKeyCreateSchema,
+  ApplicationCreateSchema,
+  AuthenticationError,
+  AuthorizationError,
+  BucketCreateSchema,
+  DEFAULT_RETRY_CONFIG,
+  DocumentUploadBase64Schema,
+  EmbedRequestSchema,
   GptClient,
+  GptCoreError,
+  InvitationCreateSchema,
+  LoginRequestSchema,
+  MessageSendSchema,
+  NetworkError,
+  NotFoundError,
+  PresignedDownloadSchema,
+  PresignedUploadSchema,
+  RateLimitError,
+  RegisterRequestSchema,
+  SearchRequestSchema,
+  ServerError,
+  ThreadCreateSchema,
+  TimeoutError,
+  ValidationError,
+  WorkspaceCreateSchema,
+  calculateBackoff,
+  collectStreamedMessage,
   eq,
   eq2,
   eq3,
@@ -1955,6 +2380,8 @@ export {
   greater_than_or_equal6,
   greater_than_or_equal7,
   greater_than_or_equal8,
+  handleApiError,
+  isRetryableError,
   less_than,
   less_than2,
   less_than3,
@@ -1979,8 +2406,15 @@ export {
   not_eq6,
   not_eq7,
   not_eq8,
+  paginateAll,
+  paginateToArray,
+  retryWithBackoff,
   role,
+  sleep,
   status,
   status2,
-  type
+  streamMessage,
+  streamSSE,
+  type,
+  withRetry
 };