@axiom-lattice/client-sdk 2.1.60 → 2.1.63

package/dist/index.js

@@ -1833,6 +1833,7 @@ __export(src_exports, {
   AuthenticationError: () => AuthenticationError,
   Client: () => Client,
   EvalClient: () => EvalClient,
+  ExportImportClient: () => ExportImportClient,
   NetworkError: () => NetworkError,
   ResourcesClient: () => ResourcesClient,
   ScheduleExecutionType: () => ScheduleExecutionType,
@@ -1911,6 +1912,36 @@ var AbstractClient = class {
         });
         return result;
       },
+      /**
+       * Enqueues a message into the thread's background queue without waiting for a response.
+       * Uses the background flag so the server returns 202 immediately.
+       * Response chunks are delivered through the shared ThreadStream SSE connection.
+       * @param options - Options for the background message
+       * @returns A promise resolving to the enqueued message ID
+       */
+      sendBackground: async (options) => {
+        const message = options.messages[options.messages.length - 1];
+        const { command, threadId, files, assistantId, mode, ...rest } = options;
+        const response = await this.makeRequest("/api/runs", {
+          method: "POST",
+          body: {
+            assistant_id: assistantId || this.assistantId,
+            thread_id: threadId,
+            message: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+            message_id: message.id,
+            files,
+            command,
+            streaming: false,
+            background: true,
+            mode,
+            ...rest
+          }
+        });
+        if (!response.success) {
+          throw new Error(response.error || "Failed to enqueue message");
+        }
+        return { messageId: response.messageId, queued: response.queued };
+      },
       /**
        * Sends a message to a thread and streams the response
        * @param options - Options for streaming a message
@@ -2610,6 +2641,22 @@ var AbstractClient = class {
         if (!response.data)
           throw new ApiError("Failed to complete task", 500);
         return response.data;
+      },
+      workItems: {
+        list: async (taskId, params) => {
+          const searchParams = new URLSearchParams();
+          if (params?.action)
+            searchParams.set("action", params.action);
+          if (params?.limit)
+            searchParams.set("limit", String(params.limit));
+          if (params?.offset)
+            searchParams.set("offset", String(params.offset));
+          const qs = searchParams.toString();
+          const response = await this.makeRequest(
+            `/api/tasks/${taskId}/work-items${qs ? `?${qs}` : ""}`
+          );
+          return response.data;
+        }
       }
     };
     this.menu = {
@@ -3824,6 +3871,97 @@ var WorkspaceClient = class {
   }
 };
 
+// src/export-import.ts
+var ExportImportClient = class {
+  constructor(config) {
+    this.baseURL = config.baseURL;
+    this.headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiKey}`,
+      ...config.headers
+    };
+  }
+  async request(url, options = {}) {
+    const fullUrl = `${this.baseURL}${url}`;
+    const response = await fetch(fullUrl, {
+      ...options,
+      headers: {
+        ...this.headers,
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const err = await response.json().catch(() => ({}));
+      throw new Error(
+        err.message || `HTTP error! Status: ${response.status}`
+      );
+    }
+    return response.json();
+  }
+  async getExportableTypes() {
+    const response = await this.request(
+      "/api/tenants/exportable-types"
+    );
+    return response.data || [];
+  }
+  async exportConfig(tenantId, entityTypes) {
+    const response = await this.request(
+      `/api/tenants/${tenantId}/export`,
+      {
+        method: "POST",
+        body: JSON.stringify({ entityTypes })
+      }
+    );
+    return response.data;
+  }
+  async exportConfigConfirm(tenantId, entityTypes) {
+    const response = await this.request(
+      `/api/tenants/${tenantId}/export/confirm`,
+      {
+        method: "POST",
+        body: JSON.stringify({ entityTypes })
+      }
+    );
+    return response.data;
+  }
+  getExportDownloadUrl(tenantId, jobId) {
+    return `${this.baseURL}/api/tenants/${tenantId}/export/${jobId}/download`;
+  }
+  async importPreview(tenantId, file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const fullUrl = `${this.baseURL}/api/tenants/${tenantId}/import/preview`;
+    const headers = { ...this.headers };
+    delete headers["Content-Type"];
+    const response = await fetch(fullUrl, {
+      method: "POST",
+      headers,
+      body: formData
+    });
+    if (!response.ok) {
+      const err = await response.json().catch(() => ({}));
+      throw new Error(
+        err.message || `HTTP error! Status: ${response.status}`
+      );
+    }
+    const json = await response.json();
+    if (!json.success || !json.data) {
+      throw new Error(json.error || "Import preview failed");
+    }
+    return json.data;
+  }
+  async importApply(tenantId, bundle, resolutions) {
+    const response = await this.request(
+      `/api/tenants/${tenantId}/import/apply`,
+      {
+        method: "POST",
+        body: JSON.stringify({ bundle, resolutions })
+      }
+    );
+    return response.data;
+  }
+};
+
 // src/ChunkMessageMerger.ts
 var import_best_effort_json_parser = require("best-effort-json-parser");
 function createSimpleMessageMerger() {
@@ -4023,6 +4161,7 @@ function createSimpleMessageMerger() {
   AuthenticationError,
   Client,
   EvalClient,
+  ExportImportClient,
   NetworkError,
   ResourcesClient,
   ScheduleExecutionType,