@docrouter/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,689 @@
+import axios, { isAxiosError } from 'axios';
+
+// src/http-client.ts
+var HttpClient = class {
+  constructor(config) {
+    this.isRefreshing = false;
+    this.failedQueue = [];
+    this.config = config;
+    this.axios = axios.create({
+      baseURL: config.baseURL,
+      timeout: config.timeout || 3e4,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    this.setupInterceptors();
+  }
+  setupInterceptors() {
+    this.axios.interceptors.request.use(
+      async (config) => {
+        const token = await this.getToken();
+        if (token) {
+          config.headers.Authorization = `Bearer ${token}`;
+        }
+        return config;
+      },
+      (error) => Promise.reject(error)
+    );
+    this.axios.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        const originalRequest = error.config;
+        if (error.response?.status === 401 && !originalRequest._retry) {
+          if (this.isRefreshing) {
+            return new Promise((resolve, reject) => {
+              this.failedQueue.push({ resolve, reject });
+            }).then(() => this.axios(originalRequest)).catch((err) => {
+              this.handleAuthError(err);
+              return Promise.reject(err);
+            });
+          }
+          originalRequest._retry = true;
+          this.isRefreshing = true;
+          try {
+            const newToken = await this.getToken();
+            if (newToken) {
+              originalRequest.headers.Authorization = `Bearer ${newToken}`;
+              this.processQueue();
+              return this.axios(originalRequest);
+            } else {
+              this.handleAuthError(error);
+              return Promise.reject(this.createApiError(error));
+            }
+          } catch (refreshError) {
+            this.processQueue(refreshError instanceof Error ? refreshError : new Error("Token refresh failed"));
+            this.handleAuthError(error);
+            return Promise.reject(this.createApiError(error));
+          } finally {
+            this.isRefreshing = false;
+          }
+        }
+        return Promise.reject(this.createApiError(error));
+      }
+    );
+  }
+  async getToken() {
+    if (this.config.token) {
+      return this.config.token;
+    }
+    if (this.config.tokenProvider) {
+      try {
+        return await this.config.tokenProvider();
+      } catch (error) {
+        console.warn("Token provider failed:", error);
+        return null;
+      }
+    }
+    return null;
+  }
+  processQueue(error = null) {
+    this.failedQueue.forEach((prom) => {
+      if (error) {
+        prom.reject(error);
+      } else {
+        prom.resolve();
+      }
+    });
+    this.failedQueue = [];
+  }
+  handleAuthError(error) {
+    if (this.config.onAuthError) {
+      this.config.onAuthError(error instanceof Error ? error : new Error("Authentication failed"));
+    }
+  }
+  createApiError(error) {
+    if (isAxiosError(error)) {
+      const message = error.response?.data?.detail || error.message || "Request failed";
+      const apiError = new Error(message);
+      apiError.status = error.response?.status;
+      apiError.code = error.code;
+      apiError.details = error.response?.data;
+      return apiError;
+    }
+    if (error instanceof Error) {
+      const apiError = error;
+      return apiError;
+    }
+    return new Error("Unknown error occurred");
+  }
+  // Public methods
+  async get(url, config) {
+    const response = await this.axios.get(url, config);
+    return response.data;
+  }
+  async post(url, data, config) {
+    const response = await this.axios.post(url, data, config);
+    return response.data;
+  }
+  async put(url, data, config) {
+    const response = await this.axios.put(url, data, config);
+    return response.data;
+  }
+  async delete(url, config) {
+    const response = await this.axios.delete(url, config);
+    return response.data;
+  }
+  async request(config) {
+    const response = await this.axios.request(config);
+    return response.data;
+  }
+  // For streaming requests
+  async stream(url, data, onChunk, onError, abortSignal) {
+    try {
+      const token = await this.getToken();
+      if (!token) {
+        throw new Error("No token available for streaming request");
+      }
+      const response = await fetch(`${this.config.baseURL}${url}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${token}`,
+          "Accept": "text/plain",
+          "Cache-Control": "no-cache"
+        },
+        body: JSON.stringify(data),
+        signal: abortSignal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      if (!response.body) {
+        throw new Error("Response body is not available for streaming");
+      }
+      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) {
+            if (line.startsWith("data: ")) {
+              try {
+                const chunkData = JSON.parse(line.slice(6));
+                onChunk(chunkData);
+                if (chunkData.done) {
+                  return;
+                }
+              } catch (parseError) {
+                console.warn("Failed to parse streaming chunk:", parseError);
+              }
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    } catch (error) {
+      if (onError) {
+        onError(error instanceof Error ? error : new Error("Streaming request failed"));
+      } else {
+        throw error;
+      }
+    }
+  }
+  // Update token
+  updateToken(token) {
+    this.config.token = token;
+  }
+  // Update token provider
+  updateTokenProvider(provider) {
+    this.config.tokenProvider = provider;
+  }
+};
+
+// src/docrouter-account.ts
+var DocRouterAccount = class {
+  constructor(config) {
+    this.http = new HttpClient({
+      baseURL: config.baseURL,
+      token: config.accountToken,
+      timeout: config.timeout,
+      retries: config.retries,
+      onAuthError: config.onAuthError
+    });
+  }
+  /**
+   * Update the account token
+   */
+  updateToken(token) {
+    this.http.updateToken(token);
+  }
+  // --------------- Organizations ---------------
+  async listOrganizations(params) {
+    const queryParams = new URLSearchParams();
+    if (params?.userId) queryParams.append("user_id", params.userId);
+    if (params?.organizationId) queryParams.append("organization_id", params.organizationId);
+    if (params?.nameSearch) queryParams.append("name_search", params.nameSearch);
+    if (params?.memberSearch) queryParams.append("member_search", params.memberSearch);
+    if (params?.skip !== void 0) queryParams.append("skip", String(params.skip));
+    if (params?.limit !== void 0) queryParams.append("limit", String(params.limit));
+    return this.http.get(`/v0/account/organizations?${queryParams.toString()}`);
+  }
+  async getOrganization(organizationId) {
+    const response = await this.listOrganizations({ organizationId });
+    return response.organizations[0];
+  }
+  async createOrganization(organization) {
+    const response = await this.http.post(`/v0/account/organizations`, organization);
+    return {
+      id: response._id || response.id,
+      name: response.name,
+      members: response.members,
+      type: response.type,
+      created_at: response.created_at,
+      updated_at: response.updated_at
+    };
+  }
+  async updateOrganization(organizationId, update) {
+    return this.http.put(`/v0/account/organizations/${organizationId}`, update);
+  }
+  async deleteOrganization(organizationId) {
+    return this.http.delete(`/v0/account/organizations/${organizationId}`);
+  }
+  // --------------- Tokens ---------------
+  async createAccountToken(request) {
+    return this.http.post(`/v0/account/access_tokens`, request);
+  }
+  async getAccountTokens() {
+    const resp = await this.http.get(`/v0/account/access_tokens`);
+    return Array.isArray(resp) ? resp : resp.access_tokens;
+  }
+  async deleteAccountToken(tokenId) {
+    return this.http.delete(`/v0/account/access_tokens/${tokenId}`);
+  }
+  async createOrganizationToken(request, organizationId) {
+    return this.http.post(`/v0/orgs/${organizationId}/access_tokens`, request);
+  }
+  async getOrganizationTokens(organizationId) {
+    return this.http.get(`/v0/orgs/${organizationId}/access_tokens`);
+  }
+  async deleteOrganizationToken(tokenId, organizationId) {
+    return this.http.delete(`/v0/orgs/${organizationId}/access_tokens/${tokenId}`);
+  }
+  // --------------- LLM (account-level) ---------------
+  async listLLMModels(params) {
+    return this.http.get("/v0/account/llm/models", {
+      params: {
+        provider_name: params.providerName,
+        provider_enabled: params.providerEnabled,
+        llm_enabled: params.llmEnabled
+      }
+    });
+  }
+  async listLLMProviders() {
+    return this.http.get("/v0/account/llm/providers");
+  }
+  async setLLMProviderConfig(providerName, request) {
+    return this.http.put(`/v0/account/llm/provider/${providerName}`, request);
+  }
+  // --------------- Users ---------------
+  async listUsers(params) {
+    const queryParams = new URLSearchParams();
+    if (params?.skip) queryParams.append("skip", String(params.skip));
+    if (params?.limit) queryParams.append("limit", String(params.limit));
+    if (params?.organization_id) queryParams.append("organization_id", params.organization_id);
+    if (params?.user_id) queryParams.append("user_id", params.user_id);
+    if (params?.search_name) queryParams.append("search_name", params.search_name);
+    return this.http.get(`/v0/account/users?${queryParams.toString()}`);
+  }
+  async getUser(userId) {
+    const response = await this.listUsers({ user_id: userId });
+    const user = response.users[0];
+    return { user };
+  }
+  async createUser(user) {
+    const created = await this.http.post(
+      "/v0/account/users",
+      user
+    );
+    return created.user ? created : { user: created };
+  }
+  async updateUser(userId, update) {
+    const updated = await this.http.put(
+      `/v0/account/users/${userId}`,
+      update
+    );
+    return updated.user ? updated : { user: updated };
+  }
+  async deleteUser(userId) {
+    await this.http.delete(`/v0/account/users/${userId}`);
+  }
+  // --------------- Email Verification ---------------
+  async sendVerificationEmail(userId) {
+    return this.http.post(`/v0/account/email/verification/send/${userId}`);
+  }
+  async sendRegistrationVerificationEmail(userId) {
+    return this.http.post(`/v0/account/email/verification/register/${userId}`);
+  }
+  async verifyEmail(token) {
+    return this.http.post(`/v0/account/email/verification/${token}`);
+  }
+  // --------------- AWS Config ---------------
+  async createAWSConfig(config) {
+    return this.http.post("/v0/account/aws_config", config);
+  }
+  async getAWSConfig() {
+    return this.http.get("/v0/account/aws_config");
+  }
+  async deleteAWSConfig() {
+    return this.http.delete("/v0/account/aws_config");
+  }
+  /**
+   * Get the current HTTP client (for advanced usage)
+   */
+  getHttpClient() {
+    return this.http;
+  }
+};
+
+// src/docrouter-org.ts
+var DocRouterOrg = class {
+  constructor(config) {
+    this.organizationId = config.organizationId;
+    this.http = new HttpClient({
+      baseURL: config.baseURL,
+      token: config.orgToken,
+      timeout: config.timeout,
+      retries: config.retries,
+      onAuthError: config.onAuthError
+    });
+  }
+  /**
+   * Update the organization token
+   */
+  updateToken(token) {
+    this.http.updateToken(token);
+  }
+  // ---------------- Documents ----------------
+  async uploadDocuments(params) {
+    const documentsPayload = params.documents.map((doc) => {
+      let base64Content;
+      if (doc.content instanceof ArrayBuffer) {
+        const buffer = Buffer.from(doc.content);
+        base64Content = buffer.toString("base64");
+      } else if (doc.content instanceof Buffer) {
+        base64Content = doc.content.toString("base64");
+      } else if (doc.content instanceof Uint8Array) {
+        const buffer = Buffer.from(doc.content);
+        base64Content = buffer.toString("base64");
+      } else {
+        const uint8Array = new Uint8Array(doc.content);
+        const buffer = Buffer.from(uint8Array);
+        base64Content = buffer.toString("base64");
+      }
+      const payload = {
+        name: doc.name,
+        content: base64Content,
+        type: doc.type
+      };
+      if (doc.metadata) payload.metadata = doc.metadata;
+      return payload;
+    });
+    return this.http.post(
+      `/v0/orgs/${this.organizationId}/documents`,
+      { documents: documentsPayload }
+    );
+  }
+  async listDocuments(params) {
+    const queryParams = {
+      skip: params?.skip || 0,
+      limit: params?.limit || 10
+    };
+    if (params?.tagIds) queryParams.tag_ids = params.tagIds;
+    if (params?.nameSearch) queryParams.name_search = params.nameSearch;
+    if (params?.metadataSearch) queryParams.metadata_search = params.metadataSearch;
+    return this.http.get(`/v0/orgs/${this.organizationId}/documents`, {
+      params: queryParams
+    });
+  }
+  async getDocument(params) {
+    const { documentId, fileType } = params;
+    const response = await this.http.get(`/v0/orgs/${this.organizationId}/documents/${documentId}?file_type=${fileType}`);
+    const binaryContent = atob(response.content);
+    const len = binaryContent.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+      bytes[i] = binaryContent.charCodeAt(i);
+    }
+    return {
+      id: response.id,
+      pdf_id: response.pdf_id,
+      document_name: response.document_name,
+      upload_date: response.upload_date,
+      uploaded_by: response.uploaded_by,
+      state: response.state,
+      tag_ids: response.tag_ids,
+      type: response.type,
+      metadata: response.metadata,
+      content: bytes.buffer
+    };
+  }
+  async updateDocument(params) {
+    const { documentId, documentName, tagIds, metadata } = params;
+    const updateData = {};
+    if (documentName !== void 0) updateData.document_name = documentName;
+    if (tagIds !== void 0) updateData.tag_ids = tagIds;
+    if (metadata !== void 0) updateData.metadata = metadata;
+    return this.http.put(`/v0/orgs/${this.organizationId}/documents/${documentId}`, updateData);
+  }
+  async deleteDocument(params) {
+    const { documentId } = params;
+    return this.http.delete(`/v0/orgs/${this.organizationId}/documents/${documentId}`);
+  }
+  // ---------------- OCR ----------------
+  async getOCRBlocks(params) {
+    const { documentId } = params;
+    return this.http.get(`/v0/orgs/${this.organizationId}/ocr/download/blocks/${documentId}`);
+  }
+  async getOCRText(params) {
+    const { documentId, pageNum } = params;
+    const url = `/v0/orgs/${this.organizationId}/ocr/download/text/${documentId}${pageNum ? `?page_num=${pageNum}` : ""}`;
+    return this.http.get(url);
+  }
+  async getOCRMetadata(params) {
+    const { documentId } = params;
+    return this.http.get(`/v0/orgs/${this.organizationId}/ocr/download/metadata/${documentId}`);
+  }
+  // ---------------- LLM ----------------
+  async runLLM(params) {
+    const { documentId, promptRevId, force } = params;
+    return this.http.post(
+      `/v0/orgs/${this.organizationId}/llm/run/${documentId}`,
+      {},
+      { params: { prompt_revid: promptRevId, force } }
+    );
+  }
+  async getLLMResult(params) {
+    const { documentId, promptRevId, fallback } = params;
+    return this.http.get(
+      `/v0/orgs/${this.organizationId}/llm/result/${documentId}`,
+      { params: { prompt_revid: promptRevId, fallback } }
+    );
+  }
+  async updateLLMResult({
+    documentId,
+    promptId,
+    result,
+    isVerified = false
+  }) {
+    const response = await this.http.put(
+      `/v0/orgs/${this.organizationId}/llm/result/${documentId}`,
+      { updated_llm_result: result, is_verified: isVerified },
+      { params: { prompt_revid: promptId } }
+    );
+    if (response.status !== 200) {
+      throw new Error(`Failed to update LLM result for document ${documentId} and prompt ${promptId}: ${response.data}`);
+    }
+    return response.data;
+  }
+  async deleteLLMResult(params) {
+    const { documentId, promptId } = params;
+    return this.http.delete(
+      `/v0/orgs/${this.organizationId}/llm/result/${documentId}`,
+      { params: { prompt_revid: promptId } }
+    );
+  }
+  async downloadAllLLMResults(params) {
+    const { documentId } = params;
+    return this.http.get(
+      `/v0/orgs/${this.organizationId}/llm/results/${documentId}/download`,
+      { responseType: "blob" }
+    );
+  }
+  // ---------------- Tags ----------------
+  async createTag(params) {
+    const { tag } = params;
+    return this.http.post(`/v0/orgs/${this.organizationId}/tags`, tag);
+  }
+  async getTag({ tagId }) {
+    return this.http.get(`/v0/orgs/${this.organizationId}/tags/${tagId}`);
+  }
+  async listTags(params) {
+    const { skip, limit, nameSearch } = params || {};
+    return this.http.get(`/v0/orgs/${this.organizationId}/tags`, {
+      params: { skip: skip || 0, limit: limit || 10, name_search: nameSearch }
+    });
+  }
+  async updateTag(params) {
+    const { tagId, tag } = params;
+    return this.http.put(`/v0/orgs/${this.organizationId}/tags/${tagId}`, tag);
+  }
+  async deleteTag(params) {
+    const { tagId } = params;
+    return this.http.delete(`/v0/orgs/${this.organizationId}/tags/${tagId}`);
+  }
+  // ---------------- Forms ----------------
+  async createForm(form) {
+    const { name, response_format } = form;
+    return this.http.post(`/v0/orgs/${this.organizationId}/forms`, { name, response_format });
+  }
+  async listForms(params) {
+    const { skip, limit, tag_ids } = params || {};
+    return this.http.get(`/v0/orgs/${this.organizationId}/forms`, {
+      params: { skip: skip || 0, limit: limit || 10, tag_ids }
+    });
+  }
+  async getForm(params) {
+    const { formRevId } = params;
+    return this.http.get(`/v0/orgs/${this.organizationId}/forms/${formRevId}`);
+  }
+  async updateForm(params) {
+    const { formId, form } = params;
+    return this.http.put(`/v0/orgs/${this.organizationId}/forms/${formId}`, form);
+  }
+  async deleteForm(params) {
+    const { formId } = params;
+    return this.http.delete(`/v0/orgs/${this.organizationId}/forms/${formId}`);
+  }
+  async submitForm(params) {
+    const { documentId, formRevId, submission_data, submitted_by } = params;
+    return this.http.post(`/v0/orgs/${this.organizationId}/forms/submissions/${documentId}`, {
+      form_revid: formRevId,
+      submission_data,
+      submitted_by
+    });
+  }
+  async getFormSubmission(params) {
+    const { documentId, formRevId } = params;
+    return this.http.get(`/v0/orgs/${this.organizationId}/forms/submissions/${documentId}?form_revid=${formRevId}`);
+  }
+  async deleteFormSubmission(params) {
+    const { documentId, formRevId } = params;
+    await this.http.delete(`/v0/orgs/${this.organizationId}/forms/submissions/${documentId}`, { params: { form_revid: formRevId } });
+  }
+  // ---------------- Prompts ----------------
+  async createPrompt(params) {
+    const { prompt } = params;
+    return this.http.post(`/v0/orgs/${this.organizationId}/prompts`, prompt);
+  }
+  async listPrompts(params) {
+    const { skip, limit, document_id, tag_ids, nameSearch } = params || {};
+    return this.http.get(`/v0/orgs/${this.organizationId}/prompts`, {
+      params: {
+        skip: skip || 0,
+        limit: limit || 10,
+        document_id,
+        tag_ids,
+        name_search: nameSearch
+      }
+    });
+  }
+  async getPrompt(params) {
+    const { promptRevId } = params;
+    return this.http.get(`/v0/orgs/${this.organizationId}/prompts/${promptRevId}`);
+  }
+  async updatePrompt(params) {
+    const { promptId, prompt } = params;
+    return this.http.put(`/v0/orgs/${this.organizationId}/prompts/${promptId}`, prompt);
+  }
+  async deletePrompt(params) {
+    const { promptId } = params;
+    return this.http.delete(`/v0/orgs/${this.organizationId}/prompts/${promptId}`);
+  }
+  // ---------------- Schemas ----------------
+  async createSchema(schema) {
+    return this.http.post(`/v0/orgs/${this.organizationId}/schemas`, schema);
+  }
+  async listSchemas(params) {
+    const { skip, limit, nameSearch } = params || {};
+    return this.http.get(`/v0/orgs/${this.organizationId}/schemas`, {
+      params: { skip: skip || 0, limit: limit || 10, name_search: nameSearch }
+    });
+  }
+  async getSchema(params) {
+    const { schemaRevId } = params;
+    return this.http.get(`/v0/orgs/${this.organizationId}/schemas/${schemaRevId}`);
+  }
+  async updateSchema(params) {
+    const { schemaId, schema } = params;
+    return this.http.put(`/v0/orgs/${this.organizationId}/schemas/${schemaId}`, schema);
+  }
+  async deleteSchema(params) {
+    const { schemaId } = params;
+    return this.http.delete(`/v0/orgs/${this.organizationId}/schemas/${schemaId}`);
+  }
+  async validateAgainstSchema(params) {
+    const { schemaRevId, data } = params;
+    return this.http.post(`/v0/orgs/${this.organizationId}/schemas/${schemaRevId}/validate`, { data });
+  }
+  // ---------------- Flows ----------------
+  async createFlow(params) {
+    const { flow } = params;
+    return this.http.post(`/v0/orgs/${this.organizationId}/flows`, flow);
+  }
+  async updateFlow(params) {
+    const { flowId, flow } = params;
+    return this.http.put(`/v0/orgs/${this.organizationId}/flows/${flowId}`, flow);
+  }
+  async listFlows(params) {
+    const { skip, limit } = params || {};
+    return this.http.get(`/v0/orgs/${this.organizationId}/flows`, {
+      params: { skip: skip || 0, limit: limit || 10 }
+    });
+  }
+  async getFlow(params) {
+    const { flowId } = params;
+    return this.http.get(`/v0/orgs/${this.organizationId}/flows/${flowId}`);
+  }
+  async deleteFlow(params) {
+    const { flowId } = params;
+    await this.http.delete(`/v0/orgs/${this.organizationId}/flows/${flowId}`);
+  }
+  // ---------------- Payments ----------------
+  async getCustomerPortal() {
+    return this.http.post(`/v0/orgs/${this.organizationId}/payments/customer-portal`, {});
+  }
+  async getSubscription() {
+    return this.http.get(`/v0/orgs/${this.organizationId}/payments/subscription`);
+  }
+  async activateSubscription() {
+    return this.http.put(`/v0/orgs/${this.organizationId}/payments/subscription`, {});
+  }
+  async cancelSubscription() {
+    return this.http.delete(`/v0/orgs/${this.organizationId}/payments/subscription`);
+  }
+  async getCurrentUsage() {
+    return this.http.get(`/v0/orgs/${this.organizationId}/payments/usage`);
+  }
+  async addCredits(amount) {
+    return this.http.post(`/v0/orgs/${this.organizationId}/payments/credits/add`, { amount });
+  }
+  async getCreditConfig() {
+    return this.http.get(`/v0/orgs/${this.organizationId}/payments/credits/config`);
+  }
+  async purchaseCredits(request) {
+    return this.http.post(`/v0/orgs/${this.organizationId}/payments/credits/purchase`, request);
+  }
+  async getUsageRange(request) {
+    return this.http.get(`/v0/orgs/${this.organizationId}/payments/usage/range`, { params: request });
+  }
+  async createCheckoutSession(planId) {
+    return this.http.post(`/v0/orgs/${this.organizationId}/payments/checkout-session`, { plan_id: planId });
+  }
+  // ---------------- LLM Chat (Org) ----------------
+  async runLLMChat(request) {
+    return this.http.post(`/v0/orgs/${this.organizationId}/llm/run`, request);
+  }
+  async runLLMChatStream(request, onChunk, onError, abortSignal) {
+    const streamingRequest = { ...request, stream: true };
+    return this.http.stream(`/v0/orgs/${this.organizationId}/llm/run`, streamingRequest, onChunk, onError, abortSignal);
+  }
+  /**
+   * Get the current HTTP client (for advanced usage)
+   */
+  getHttpClient() {
+    return this.http;
+  }
+};
+
+export { DocRouterAccount, DocRouterOrg, HttpClient };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map