@semiont/api-client 0.2.33-build.79 → 0.2.33-build.81

package/dist/index.js

@@ -172,34 +172,20 @@ function createSSEStream(url, fetchOptions, config, logger) {
 // src/sse/index.ts
 var SSEClient = class {
   baseUrl;
-  accessToken = null;
   logger;
   constructor(config) {
     this.baseUrl = config.baseUrl.endsWith("/") ? config.baseUrl.slice(0, -1) : config.baseUrl;
-    this.accessToken = config.accessToken || null;
     this.logger = config.logger;
   }
-  /**
-   * Set the access token for authenticated requests
-   */
-  setAccessToken(token) {
-    this.accessToken = token;
-  }
-  /**
-   * Clear the access token
-   */
-  clearAccessToken() {
-    this.accessToken = null;
-  }
   /**
    * Get common headers for SSE requests
    */
-  getHeaders() {
+  getHeaders(auth) {
     const headers = {
       "Content-Type": "application/json"
     };
-    if (this.accessToken) {
-      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    if (auth) {
+      headers["Authorization"] = `Bearer ${auth}`;
     }
     return headers;
   }
@@ -221,13 +207,15 @@ var SSEClient = class {
    *
    * @param resourceId - Resource URI or ID
    * @param request - Detection configuration (entity types to detect)
+   * @param options - Request options (auth token)
    * @returns SSE stream controller with progress/complete/error callbacks
    *
    * @example
    * ```typescript
-   * const stream = sseClient.detectAnnotations(
+   * const stream = sseClient.detectReferences(
    *   'http://localhost:4000/resources/doc-123',
-   *   { entityTypes: ['Person', 'Organization'] }
+   *   { entityTypes: ['Person', 'Organization'] },
+   *   { auth: 'your-token' }
    * );
    *
    * stream.onProgress((progress) => {
@@ -247,20 +235,20 @@ var SSEClient = class {
    * stream.close();
    * ```
    */
-  detectAnnotations(resourceId, request) {
+  detectReferences(resourceId, request, options) {
     const id = this.extractId(resourceId);
     const url = `${this.baseUrl}/resources/${id}/detect-annotations-stream`;
     return createSSEStream(
       url,
       {
         method: "POST",
-        headers: this.getHeaders(),
+        headers: this.getHeaders(options?.auth),
         body: JSON.stringify(request)
       },
       {
-        progressEvents: ["detection-started", "detection-progress"],
-        completeEvent: "detection-complete",
-        errorEvent: "detection-error"
+        progressEvents: ["reference-detection-started", "reference-detection-progress"],
+        completeEvent: "reference-detection-complete",
+        errorEvent: "reference-detection-error"
       },
       this.logger
     );
@@ -273,6 +261,7 @@ var SSEClient = class {
    * @param resourceId - Source resource URI or ID
    * @param annotationId - Annotation URI or ID to use as generation source
    * @param request - Generation options (title, prompt, language)
+   * @param options - Request options (auth token)
    * @returns SSE stream controller with progress/complete/error callbacks
    *
    * @example
@@ -280,7 +269,8 @@ var SSEClient = class {
    * const stream = sseClient.generateResourceFromAnnotation(
    *   'http://localhost:4000/resources/doc-123',
    *   'http://localhost:4000/annotations/ann-456',
-   *   { language: 'es', title: 'Spanish Summary' }
+   *   { language: 'es', title: 'Spanish Summary' },
+   *   { auth: 'your-token' }
    * );
    *
    * stream.onProgress((progress) => {
@@ -300,7 +290,7 @@ var SSEClient = class {
    * stream.close();
    * ```
    */
-  generateResourceFromAnnotation(resourceId, annotationId, request) {
+  generateResourceFromAnnotation(resourceId, annotationId, request, options) {
     const resId = this.extractId(resourceId);
     const annId = this.extractId(annotationId);
     const url = `${this.baseUrl}/resources/${resId}/annotations/${annId}/generate-resource-stream`;
@@ -308,7 +298,7 @@ var SSEClient = class {
       url,
       {
         method: "POST",
-        headers: this.getHeaders(),
+        headers: this.getHeaders(options?.auth),
         body: JSON.stringify(request)
       },
       {
@@ -326,13 +316,15 @@ var SSEClient = class {
    *
    * @param resourceId - Resource URI or ID
    * @param request - Detection configuration (optional instructions)
+   * @param options - Request options (auth token)
    * @returns SSE stream controller with progress/complete/error callbacks
    *
    * @example
    * ```typescript
    * const stream = sseClient.detectHighlights(
    *   'http://localhost:4000/resources/doc-123',
-   *   { instructions: 'Focus on key technical points' }
+   *   { instructions: 'Focus on key technical points' },
+   *   { auth: 'your-token' }
    * );
    *
    * stream.onProgress((progress) => {
@@ -352,14 +344,14 @@ var SSEClient = class {
    * stream.close();
    * ```
    */
-  detectHighlights(resourceId, request = {}) {
+  detectHighlights(resourceId, request = {}, options) {
     const id = this.extractId(resourceId);
     const url = `${this.baseUrl}/resources/${id}/detect-highlights-stream`;
     return createSSEStream(
       url,
       {
         method: "POST",
-        headers: this.getHeaders(),
+        headers: this.getHeaders(options?.auth),
         body: JSON.stringify(request)
       },
       {
@@ -377,13 +369,15 @@ var SSEClient = class {
    *
    * @param resourceId - Resource URI or ID
    * @param request - Detection configuration (optional instructions)
+   * @param options - Request options (auth token)
    * @returns SSE stream controller with progress/complete/error callbacks
    *
    * @example
    * ```typescript
    * const stream = sseClient.detectAssessments(
    *   'http://localhost:4000/resources/doc-123',
-   *   { instructions: 'Evaluate claims for accuracy' }
+   *   { instructions: 'Evaluate claims for accuracy' },
+   *   { auth: 'your-token' }
    * );
    *
    * stream.onProgress((progress) => {
@@ -403,14 +397,14 @@ var SSEClient = class {
    * stream.close();
    * ```
    */
-  detectAssessments(resourceId, request = {}) {
+  detectAssessments(resourceId, request = {}, options) {
     const id = this.extractId(resourceId);
     const url = `${this.baseUrl}/resources/${id}/detect-assessments-stream`;
     return createSSEStream(
       url,
       {
         method: "POST",
-        headers: this.getHeaders(),
+        headers: this.getHeaders(options?.auth),
         body: JSON.stringify(request)
       },
       {
@@ -430,14 +424,19 @@ var SSEClient = class {
    *
    * @param resourceId - Resource URI or ID
    * @param request - Detection configuration (optional instructions and tone)
+   * @param options - Request options (auth token)
    * @returns SSE stream controller with progress/complete/error callbacks
    *
    * @example
    * ```typescript
-   * const stream = sseClient.detectComments('http://localhost:4000/resources/doc-123', {
-   *   instructions: 'Focus on technical terminology',
-   *   tone: 'scholarly'
-   * });
+   * const stream = sseClient.detectComments(
+   *   'http://localhost:4000/resources/doc-123',
+   *   {
+   *     instructions: 'Focus on technical terminology',
+   *     tone: 'scholarly'
+   *   },
+   *   { auth: 'your-token' }
+   * );
    *
    * stream.onProgress((progress) => {
    *   console.log(`${progress.status}: ${progress.percentage}%`);
@@ -455,14 +454,14 @@ var SSEClient = class {
    * stream.close();
    * ```
    */
-  detectComments(resourceId, request = {}) {
+  detectComments(resourceId, request = {}, options) {
     const id = this.extractId(resourceId);
     const url = `${this.baseUrl}/resources/${id}/detect-comments-stream`;
     return createSSEStream(
       url,
       {
         method: "POST",
-        headers: this.getHeaders(),
+        headers: this.getHeaders(options?.auth),
         body: JSON.stringify(request)
       },
       {
@@ -482,14 +481,19 @@ var SSEClient = class {
    *
    * @param resourceId - Resource URI or ID
    * @param request - Detection configuration (schema and categories to detect)
+   * @param options - Request options (auth token)
    * @returns SSE stream controller with progress/complete/error callbacks
    *
    * @example
    * ```typescript
-   * const stream = sseClient.detectTags('http://localhost:4000/resources/doc-123', {
-   *   schemaId: 'legal-irac',
-   *   categories: ['Issue', 'Rule', 'Application', 'Conclusion']
-   * });
+   * const stream = sseClient.detectTags(
+   *   'http://localhost:4000/resources/doc-123',
+   *   {
+   *     schemaId: 'legal-irac',
+   *     categories: ['Issue', 'Rule', 'Application', 'Conclusion']
+   *   },
+   *   { auth: 'your-token' }
+   * );
    *
    * stream.onProgress((progress) => {
    *   console.log(`${progress.status}: ${progress.percentage}%`);
@@ -508,14 +512,14 @@ var SSEClient = class {
    * stream.close();
    * ```
    */
-  detectTags(resourceId, request) {
+  detectTags(resourceId, request, options) {
     const id = this.extractId(resourceId);
     const url = `${this.baseUrl}/resources/${id}/detect-tags-stream`;
     return createSSEStream(
       url,
       {
         method: "POST",
-        headers: this.getHeaders(),
+        headers: this.getHeaders(options?.auth),
         body: JSON.stringify(request)
       },
       {
@@ -535,11 +539,15 @@ var SSEClient = class {
    * This stream does NOT have a complete event - it stays open until explicitly closed.
    *
    * @param resourceId - Resource URI or ID to subscribe to
+   * @param options - Request options (auth token)
    * @returns SSE stream controller with event callback
    *
    * @example
    * ```typescript
-   * const stream = sseClient.resourceEvents('http://localhost:4000/resources/doc-123');
+   * const stream = sseClient.resourceEvents(
+   *   'http://localhost:4000/resources/doc-123',
+   *   { auth: 'your-token' }
+   * );
    *
    * stream.onProgress((event) => {
    *   console.log(`Event: ${event.type}`);
@@ -556,14 +564,14 @@ var SSEClient = class {
    * stream.close();
    * ```
    */
-  resourceEvents(resourceId) {
+  resourceEvents(resourceId, options) {
     const id = this.extractId(resourceId);
     const url = `${this.baseUrl}/resources/${id}/events/stream`;
-    return createSSEStream(
+    const stream = createSSEStream(
       url,
       {
         method: "GET",
-        headers: this.getHeaders()
+        headers: this.getHeaders(options?.auth)
       },
       {
         progressEvents: ["*"],
@@ -577,6 +585,13 @@ var SSEClient = class {
       },
       this.logger
     );
+    if (options?.onConnected) {
+      stream.on?.("stream-connected", options.onConnected);
+    } else {
+      stream.on?.("stream-connected", () => {
+      });
+    }
+    return stream;
   }
 };
 
@@ -593,7 +608,6 @@ var APIError = class extends Error {
 var SemiontApiClient = class {
   http;
   baseUrl;
-  accessToken = null;
   logger;
   /**
    * SSE streaming client for real-time operations
@@ -605,7 +619,8 @@ var SemiontApiClient = class {
    * ```typescript
    * const stream = client.sse.detectAnnotations(
    *   resourceId,
-   *   { entityTypes: ['Person', 'Organization'] }
+   *   { entityTypes: ['Person', 'Organization'] },
+   *   { auth: accessToken }
    * );
    *
    * stream.onProgress((p) => console.log(p.message));
@@ -615,7 +630,7 @@ var SemiontApiClient = class {
    */
   sse;
   constructor(config) {
-    const { baseUrl: baseUrl2, accessToken: accessToken2, timeout = 3e4, retry = 2, logger } = config;
+    const { baseUrl: baseUrl2, timeout = 3e4, retry = 2, logger } = config;
     this.logger = logger;
     this.baseUrl = baseUrl2.endsWith("/") ? baseUrl2.slice(0, -1) : baseUrl2;
     this.http = ky.create({
@@ -623,9 +638,10 @@ var SemiontApiClient = class {
       retry,
       hooks: {
         beforeRequest: [
-          (request) => {
-            if (this.accessToken) {
-              request.headers.set("Authorization", `Bearer ${this.accessToken}`);
+          (request, options) => {
+            const auth = options.auth;
+            if (auth) {
+              request.headers.set("Authorization", `Bearer ${auth}`);
             }
             if (this.logger) {
               this.logger.debug("HTTP Request", {
@@ -633,7 +649,7 @@ var SemiontApiClient = class {
                 url: request.url,
                 method: request.method,
                 timestamp: Date.now(),
-                hasAuth: !!this.accessToken
+                hasAuth: !!auth
               });
             }
           }
@@ -679,66 +695,60 @@ var SemiontApiClient = class {
         ]
       }
     });
-    if (accessToken2) {
-      this.accessToken = accessToken2;
-    }
     this.sse = new SSEClient({
       baseUrl: this.baseUrl,
-      accessToken: this.accessToken || void 0,
       logger: this.logger
     });
   }
-  /**
-   * Set the access token for authenticated requests
-   */
-  setAccessToken(token) {
-    this.accessToken = token;
-    this.sse.setAccessToken(token);
-  }
-  /**
-   * Clear the access token
-   */
-  clearAccessToken() {
-    this.accessToken = null;
-    this.sse.clearAccessToken();
-  }
   // ============================================================================
   // AUTHENTICATION
   // ============================================================================
-  async authenticatePassword(email2, password) {
-    const response = await this.http.post(`${this.baseUrl}/api/tokens/password`, { json: { email: email2, password } }).json();
-    if (response.token) {
-      this.setAccessToken(response.token);
-    }
-    return response;
+  async authenticatePassword(email2, password, options) {
+    return this.http.post(`${this.baseUrl}/api/tokens/password`, {
+      json: { email: email2, password },
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async refreshToken(token) {
-    const response = await this.http.post(`${this.baseUrl}/api/tokens/refresh`, { json: { refreshToken: token } }).json();
-    if (response.access_token) {
-      this.setAccessToken(response.access_token);
-    }
-    return response;
+  async refreshToken(token, options) {
+    return this.http.post(`${this.baseUrl}/api/tokens/refresh`, {
+      json: { refreshToken: token },
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async authenticateGoogle(credential) {
-    const response = await this.http.post(`${this.baseUrl}/api/tokens/google`, { json: { credential } }).json();
-    if (response.token) {
-      this.setAccessToken(response.token);
-    }
-    return response;
+  async authenticateGoogle(credential, options) {
+    return this.http.post(`${this.baseUrl}/api/tokens/google`, {
+      json: { credential },
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async generateMCPToken() {
-    return this.http.post(`${this.baseUrl}/api/tokens/mcp-generate`).json();
+  async generateMCPToken(options) {
+    return this.http.post(`${this.baseUrl}/api/tokens/mcp-generate`, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
   // ============================================================================
   // USERS
   // ============================================================================
-  async getMe() {
-    return this.http.get(`${this.baseUrl}/api/users/me`).json();
+  async getMe(options) {
+    return this.http.get(`${this.baseUrl}/api/users/me`, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async acceptTerms() {
-    return this.http.post(`${this.baseUrl}/api/users/accept-terms`).json();
+  async acceptTerms(options) {
+    return this.http.post(`${this.baseUrl}/api/users/accept-terms`, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async logout() {
+  async logout(options) {
+    if (options) {
+      return this.http.post(`${this.baseUrl}/api/users/logout`, options).json();
+    }
     return this.http.post(`${this.baseUrl}/api/users/logout`).json();
   }
   // ============================================================================
@@ -756,8 +766,9 @@ var SemiontApiClient = class {
    * @param data.creationMethod - Optional creation method
    * @param data.sourceAnnotationId - Optional source annotation ID
    * @param data.sourceResourceId - Optional source resource ID
+   * @param options - Request options including auth
    */
-  async createResource(data) {
+  async createResource(data, options) {
     const formData = new FormData();
     formData.append("name", data.name);
     formData.append("format", data.format);
@@ -784,38 +795,46 @@ var SemiontApiClient = class {
     if (data.sourceResourceId) {
       formData.append("sourceResourceId", data.sourceResourceId);
     }
-    return this.http.post(`${this.baseUrl}/resources`, { body: formData }).json();
+    return this.http.post(`${this.baseUrl}/resources`, {
+      body: formData,
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async getResource(resourceUri2) {
-    return this.http.get(resourceUri2).json();
+  async getResource(resourceUri2, options) {
+    return this.http.get(resourceUri2, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
   /**
    * Get resource representation using W3C content negotiation
    * Returns raw binary content (images, PDFs, text, etc.) with content type
    *
    * @param resourceUri - Full resource URI
-   * @param options - Options including Accept header for content negotiation
+   * @param options - Options including Accept header for content negotiation and auth
    * @returns Object with data (ArrayBuffer) and contentType (string)
    *
    * @example
    * ```typescript
    * // Get markdown representation
-   * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'text/markdown' });
+   * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'text/markdown', auth: token });
    * const markdown = new TextDecoder().decode(data);
    *
    * // Get image representation
-   * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'image/png' });
+   * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'image/png', auth: token });
    * const blob = new Blob([data], { type: contentType });
    *
    * // Get PDF representation
-   * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'application/pdf' });
+   * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'application/pdf', auth: token });
    * ```
    */
   async getResourceRepresentation(resourceUri2, options) {
     const response = await this.http.get(resourceUri2, {
       headers: {
         Accept: options?.accept || "text/plain"
-      }
+      },
+      auth: options?.auth
     });
     const contentType = response.headers.get("content-type") || "application/octet-stream";
     const data = await response.arrayBuffer();
@@ -830,14 +849,15 @@ var SemiontApiClient = class {
    * until the stream is fully consumed or closed.
    *
    * @param resourceUri - Full resource URI
-   * @param options - Options including Accept header for content negotiation
+   * @param options - Options including Accept header for content negotiation and auth
    * @returns Object with stream (ReadableStream) and contentType (string)
    *
    * @example
    * ```typescript
    * // Stream large file
    * const { stream, contentType } = await client.getResourceRepresentationStream(rUri, {
-   *   accept: 'video/mp4'
+   *   accept: 'video/mp4',
+   *   auth: token
    * });
    *
    * // Consume stream chunk by chunk (never loads entire file into memory)
@@ -860,7 +880,8 @@ var SemiontApiClient = class {
     const response = await this.http.get(resourceUri2, {
       headers: {
         Accept: options?.accept || "text/plain"
-      }
+      },
+      auth: options?.auth
     });
     const contentType = response.headers.get("content-type") || "application/octet-stream";
     if (!response.body) {
@@ -868,21 +889,35 @@ var SemiontApiClient = class {
     }
     return { stream: response.body, contentType };
   }
-  async listResources(limit, archived, query) {
+  async listResources(limit, archived, query, options) {
     const searchParams = new URLSearchParams();
     if (limit) searchParams.append("limit", limit.toString());
     if (archived !== void 0) searchParams.append("archived", archived.toString());
     if (query) searchParams.append("q", query);
-    return this.http.get(`${this.baseUrl}/resources`, { searchParams }).json();
+    return this.http.get(`${this.baseUrl}/resources`, {
+      searchParams,
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async updateResource(resourceUri2, data) {
-    return this.http.patch(resourceUri2, { json: data }).json();
+  async updateResource(resourceUri2, data, options) {
+    return this.http.patch(resourceUri2, {
+      json: data,
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async getResourceEvents(resourceUri2) {
-    return this.http.get(`${resourceUri2}/events`).json();
+  async getResourceEvents(resourceUri2, options) {
+    return this.http.get(`${resourceUri2}/events`, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async getResourceAnnotations(resourceUri2) {
-    return this.http.get(`${resourceUri2}/annotations`).json();
+  async getResourceAnnotations(resourceUri2, options) {
+    return this.http.get(`${resourceUri2}/annotations`, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
   async getAnnotationLLMContext(resourceUri2, annotationId, options) {
     const searchParams = new URLSearchParams();
@@ -891,84 +926,149 @@ var SemiontApiClient = class {
     }
     return this.http.get(
       `${resourceUri2}/annotations/${annotationId}/llm-context`,
-      { searchParams }
+      {
+        searchParams,
+        auth: options?.auth
+      }
     ).json();
   }
-  async getResourceReferencedBy(resourceUri2) {
-    return this.http.get(`${resourceUri2}/referenced-by`).json();
+  async getResourceReferencedBy(resourceUri2, options) {
+    return this.http.get(`${resourceUri2}/referenced-by`, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async generateCloneToken(resourceUri2) {
-    return this.http.post(`${resourceUri2}/clone-with-token`).json();
+  async generateCloneToken(resourceUri2, options) {
+    return this.http.post(`${resourceUri2}/clone-with-token`, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async getResourceByToken(token) {
-    return this.http.get(`${this.baseUrl}/api/resources/token/${token}`).json();
+  async getResourceByToken(token, options) {
+    return this.http.get(`${this.baseUrl}/api/resources/token/${token}`, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async createResourceFromToken(data) {
-    return this.http.post(`${this.baseUrl}/api/resources/create-from-token`, { json: data }).json();
+  async createResourceFromToken(data, options) {
+    return this.http.post(`${this.baseUrl}/api/resources/create-from-token`, {
+      json: data,
+      ...options,
+      auth: options?.auth
+    }).json();
   }
   // ============================================================================
   // ANNOTATIONS
   // ============================================================================
-  async createAnnotation(resourceUri2, data) {
-    return this.http.post(`${resourceUri2}/annotations`, { json: data }).json();
+  async createAnnotation(resourceUri2, data, options) {
+    return this.http.post(`${resourceUri2}/annotations`, {
+      json: data,
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async getAnnotation(annotationUri2) {
-    return this.http.get(annotationUri2).json();
+  async getAnnotation(annotationUri2, options) {
+    return this.http.get(annotationUri2, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async getResourceAnnotation(annotationUri2) {
-    return this.http.get(annotationUri2).json();
+  async getResourceAnnotation(annotationUri2, options) {
+    return this.http.get(annotationUri2, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async listAnnotations(resourceUri2, motivation) {
+  async listAnnotations(resourceUri2, motivation, options) {
     const searchParams = new URLSearchParams();
     if (motivation) searchParams.append("motivation", motivation);
-    return this.http.get(`${resourceUri2}/annotations`, { searchParams }).json();
+    return this.http.get(`${resourceUri2}/annotations`, {
+      searchParams,
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async deleteAnnotation(annotationUri2) {
-    await this.http.delete(annotationUri2);
+  async deleteAnnotation(annotationUri2, options) {
+    await this.http.delete(annotationUri2, {
+      ...options,
+      auth: options?.auth
+    });
   }
-  async updateAnnotationBody(annotationUri2, data) {
+  async updateAnnotationBody(annotationUri2, data, options) {
     return this.http.put(`${annotationUri2}/body`, {
-      json: data
+      json: data,
+      ...options,
+      auth: options?.auth
     }).json();
   }
-  async getAnnotationHistory(annotationUri2) {
+  async getAnnotationHistory(annotationUri2, options) {
+    if (options) {
+      return this.http.get(`${annotationUri2}/history`, options).json();
+    }
     return this.http.get(`${annotationUri2}/history`).json();
   }
   // ============================================================================
   // ENTITY TYPES
   // ============================================================================
-  async addEntityType(type) {
-    return this.http.post(`${this.baseUrl}/api/entity-types`, { json: { type } }).json();
+  async addEntityType(type, options) {
+    return this.http.post(`${this.baseUrl}/api/entity-types`, {
+      json: { type },
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async addEntityTypesBulk(types) {
-    return this.http.post(`${this.baseUrl}/api/entity-types/bulk`, { json: { tags: types } }).json();
+  async addEntityTypesBulk(types, options) {
+    return this.http.post(`${this.baseUrl}/api/entity-types/bulk`, {
+      json: { tags: types },
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async listEntityTypes() {
-    return this.http.get(`${this.baseUrl}/api/entity-types`).json();
+  async listEntityTypes(options) {
+    return this.http.get(`${this.baseUrl}/api/entity-types`, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
   // ============================================================================
   // ADMIN
   // ============================================================================
-  async listUsers() {
-    return this.http.get(`${this.baseUrl}/api/admin/users`).json();
+  async listUsers(options) {
+    return this.http.get(`${this.baseUrl}/api/admin/users`, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async getUserStats() {
-    return this.http.get(`${this.baseUrl}/api/admin/users/stats`).json();
+  async getUserStats(options) {
+    return this.http.get(`${this.baseUrl}/api/admin/users/stats`, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
   /**
    * Update a user by ID
    * Note: Users use DID identifiers (did:web:domain:users:id), not HTTP URIs.
    */
-  async updateUser(id, data) {
-    return this.http.patch(`${this.baseUrl}/api/admin/users/${id}`, { json: data }).json();
+  async updateUser(id, data, options) {
+    return this.http.patch(`${this.baseUrl}/api/admin/users/${id}`, {
+      json: data,
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async getOAuthConfig() {
-    return this.http.get(`${this.baseUrl}/api/admin/oauth/config`).json();
+  async getOAuthConfig(options) {
+    return this.http.get(`${this.baseUrl}/api/admin/oauth/config`, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
   // ============================================================================
   // JOB STATUS
   // ============================================================================
-  async getJobStatus(id) {
+  async getJobStatus(id, options) {
+    if (options) {
+      return this.http.get(`${this.baseUrl}/api/jobs/${id}`, options).json();
+    }
     return this.http.get(`${this.baseUrl}/api/jobs/${id}`).json();
   }
   /**
@@ -982,7 +1082,7 @@ var SemiontApiClient = class {
     const timeout = options?.timeout ?? 6e4;
     const startTime = Date.now();
     while (true) {
-      const status = await this.getJobStatus(id);
+      const status = await this.getJobStatus(id, { auth: options?.auth });
       if (options?.onProgress) {
         options.onProgress(status);
       }
@@ -1004,15 +1104,24 @@ var SemiontApiClient = class {
     if (options?.maxResources !== void 0) searchParams.append("maxResources", options.maxResources.toString());
     if (options?.includeContent !== void 0) searchParams.append("includeContent", options.includeContent.toString());
     if (options?.includeSummary !== void 0) searchParams.append("includeSummary", options.includeSummary.toString());
-    return this.http.get(`${resourceUri2}/llm-context`, { searchParams }).json();
+    return this.http.get(`${resourceUri2}/llm-context`, {
+      searchParams,
+      auth: options?.auth
+    }).json();
   }
   // ============================================================================
   // SYSTEM STATUS
   // ============================================================================
-  async healthCheck() {
-    return this.http.get(`${this.baseUrl}/api/health`).json();
+  async healthCheck(options) {
+    return this.http.get(`${this.baseUrl}/api/health`, {
+      ...options,
+      auth: options?.auth
+    }).json();
   }
-  async getStatus() {
+  async getStatus(options) {
+    if (options) {
+      return this.http.get(`${this.baseUrl}/api/status`, options).json();
+    }
     return this.http.get(`${this.baseUrl}/api/status`).json();
   }
 };