@axiom-lattice/client-sdk 3.0.6 → 4.0.0

package/dist/index.mjs

@@ -2129,6 +2129,77 @@ var AbstractClient = class {
         }
       }
     };
+    /**
+     * A2A API keys namespace for managing A2A API keys
+     */
+    this.a2aKeys = {
+      /**
+       * Lists A2A API keys, optionally filtered by tenant
+       * Key values are masked in list responses
+       * @param params - Optional tenant filter and pagination
+       * @returns A promise that resolves to the list of key records and total
+       */
+      list: async (params) => {
+        const searchParams = new URLSearchParams();
+        if (params?.tenantId)
+          searchParams.set("tenantId", params.tenantId);
+        if (params?.limit !== void 0)
+          searchParams.set("limit", String(params.limit));
+        if (params?.offset !== void 0)
+          searchParams.set("offset", String(params.offset));
+        const qs = searchParams.toString();
+        const response = await this.makeRequest(`/api/a2a/keys${qs ? `?${qs}` : ""}`);
+        return response.data;
+      },
+      /**
+       * Creates a new A2A API key
+       * The full key value is returned only from this call
+       * @param input - Key creation input (tenant, project, optional assistant whitelist and label)
+       * @returns A promise that resolves to the created key record (full key value)
+       */
+      create: async (input) => {
+        const response = await this.makeRequest("/api/a2a/keys", { method: "POST", body: input });
+        return response.data;
+      },
+      /**
+       * Permanently deletes an A2A API key
+       * @param id - Key identifier
+       * @returns A promise that resolves when the key is deleted
+       */
+      delete: async (id) => {
+        await this.makeRequest(`/api/a2a/keys/${id}`, {
+          method: "DELETE"
+        });
+      },
+      /**
+       * Disables an A2A API key
+       * @param id - Key identifier
+       * @returns A promise that resolves to the updated key record
+       */
+      disable: async (id) => {
+        const response = await this.makeRequest(`/api/a2a/keys/${id}/disable`, { method: "POST" });
+        return response.data;
+      },
+      /**
+       * Enables a previously disabled A2A API key
+       * @param id - Key identifier
+       * @returns A promise that resolves to the updated key record
+       */
+      enable: async (id) => {
+        const response = await this.makeRequest(`/api/a2a/keys/${id}/enable`, { method: "POST" });
+        return response.data;
+      },
+      /**
+       * Rotates an A2A API key, generating a new key value
+       * The full new key value is returned only from this call
+       * @param id - Key identifier
+       * @returns A promise that resolves to the updated key record (full new key value)
+       */
+      rotate: async (id) => {
+        const response = await this.makeRequest(`/api/a2a/keys/${id}/rotate`, { method: "POST" });
+        return response.data;
+      }
+    };
     /**
      * Skills namespace for managing skills
      */
@@ -2649,11 +2720,11 @@ var AbstractClient = class {
       delete: async (id) => {
         await this.makeRequest(`/api/tasks/${id}`, { method: "DELETE" });
       },
-      complete: async (id) => {
-        const response = await this.makeRequest(`/api/tasks/${id}/complete`, { method: "PATCH" });
+      complete: async (id, data) => {
+        const response = await this.makeRequest(`/api/tasks/${id}/complete`, { method: "PATCH", body: data });
         if (!response.data)
           throw new ApiError("Failed to complete task", 500);
-        return response.data;
+        return response;
       },
       workItems: {
         list: async (taskId, params) => {
@@ -2960,6 +3031,182 @@ var ResourcesClient = class {
   }
 };
 
+// src/export-import.ts
+function base64ToBytes(base64) {
+  if (typeof globalThis.atob === "function") {
+    const binary = globalThis.atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+      bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+  }
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+function bytesToArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+async function archiveToBlob(archive) {
+  if (typeof archive === "string") {
+    return {
+      blob: new Blob([bytesToArrayBuffer(base64ToBytes(archive))], { type: "application/gzip" }),
+      filename: "tenant-import.tar.gz"
+    };
+  }
+  if (archive instanceof Blob) {
+    const filename = "name" in archive && typeof archive.name === "string" ? archive.name : "tenant-import.tar.gz";
+    return { blob: archive, filename };
+  }
+  const bytes = archive instanceof Uint8Array ? archive : archive instanceof ArrayBuffer ? new Uint8Array(archive) : new Uint8Array(await archive.arrayBuffer());
+  return {
+    blob: new Blob([bytesToArrayBuffer(bytes)], { type: "application/gzip" }),
+    filename: "tenant-import.tar.gz"
+  };
+}
+function attachmentFilename(contentDisposition) {
+  if (!contentDisposition)
+    return "tenant-export.tar.gz";
+  const encoded = contentDisposition.match(/filename\*=UTF-8''([^;]+)/i)?.[1];
+  if (encoded) {
+    try {
+      return decodeURIComponent(encoded);
+    } catch {
+      return encoded;
+    }
+  }
+  return contentDisposition.match(/filename="([^"]+)"/i)?.[1] ?? contentDisposition.match(/filename=([^;\s]+)/i)?.[1] ?? "tenant-export.tar.gz";
+}
+var ExportImportClient = class {
+  /**
+   * Creates an export/import client.
+   *
+   * @param config - Base client configuration.
+   * @param headerProvider - Optional provider for headers that change after construction.
+   */
+  constructor(config, headerProvider) {
+    this.baseURL = config.baseURL;
+    this.headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiKey}`,
+      ...config.headers
+    };
+    this.headerProvider = headerProvider;
+  }
+  async request(url, options = {}) {
+    const headers = {
+      ...this.headers,
+      ...this.headerProvider?.(),
+      ...options.headers
+    };
+    if (options.body instanceof FormData) {
+      for (const name of Object.keys(headers)) {
+        if (name.toLowerCase() === "content-type")
+          delete headers[name];
+      }
+    }
+    const response = await fetch(`${this.baseURL}${url}`, {
+      method: options.method ?? "GET",
+      ...options,
+      headers
+    });
+    const envelope = await response.json().catch(() => ({}));
+    if (!response.ok || envelope.success === false) {
+      throw new Error(
+        envelope.message || envelope.error || `HTTP error! Status: ${response.status}`
+      );
+    }
+    if (envelope.data === void 0) {
+      throw new Error(envelope.message || envelope.error || "API response contained no data");
+    }
+    return envelope.data;
+  }
+  /** Returns all entity types registered for export. */
+  getExportableTypes() {
+    return this.request("/api/tenants/exportable-types");
+  }
+  /** Starts an export or returns dependencies requiring confirmation. */
+  exportConfig(tenantId, entityTypes, entityIds) {
+    return this.request(`/api/tenants/${tenantId}/export`, {
+      method: "POST",
+      body: JSON.stringify({ entityTypes, ...entityIds ? { entityIds } : {} })
+    });
+  }
+  /** Starts an export after confirming dependency additions. */
+  exportConfigConfirm(tenantId, entityTypes, entityIds) {
+    return this.request(`/api/tenants/${tenantId}/export/confirm`, {
+      method: "POST",
+      body: JSON.stringify({ entityTypes, ...entityIds ? { entityIds } : {} })
+    });
+  }
+  /** Lists selectable entities for the requested export types. */
+  previewEntities(tenantId, entityTypes) {
+    return this.request(
+      `/api/tenants/${tenantId}/export/entities`,
+      { method: "POST", body: JSON.stringify({ entityTypes }) }
+    );
+  }
+  /** Returns the gateway URL for an export download job. */
+  getExportDownloadUrl(tenantId, jobId) {
+    return `${this.baseURL}/api/tenants/${tenantId}/export/${jobId}/download`;
+  }
+  /** Downloads an export archive as raw bytes. */
+  async downloadExport(tenantId, jobId) {
+    const response = await fetch(
+      `${this.baseURL}/api/tenants/${tenantId}/export/${jobId}/download`,
+      {
+        method: "GET",
+        headers: {
+          ...this.headers,
+          ...this.headerProvider?.()
+        }
+      }
+    );
+    if (!response.ok) {
+      const envelope = await response.json().catch(() => ({}));
+      throw new Error(
+        envelope.message || envelope.error || `HTTP error! Status: ${response.status}`
+      );
+    }
+    return {
+      filename: attachmentFilename(response.headers.get("Content-Disposition")),
+      data: new Uint8Array(await response.arrayBuffer())
+    };
+  }
+  /** Previews an archive or plain JSON bundle import. */
+  async importPreview(tenantId, source) {
+    if (source.archive !== void 0) {
+      const form = new FormData();
+      const { blob, filename } = await archiveToBlob(source.archive);
+      form.append("file", blob, filename);
+      return this.request(`/api/tenants/${tenantId}/import/preview`, {
+        method: "POST",
+        body: form
+      });
+    }
+    return this.request(`/api/tenants/${tenantId}/import/preview`, {
+      method: "POST",
+      body: JSON.stringify({ bundle: source.bundle })
+    });
+  }
+  /** Applies an archive or plain JSON bundle import with conflict resolutions. */
+  async importApply(tenantId, source, resolutions) {
+    if (source.archive !== void 0) {
+      const form = new FormData();
+      const { blob, filename } = await archiveToBlob(source.archive);
+      form.append("file", blob, filename);
+      form.append("resolutions", JSON.stringify(resolutions));
+      return this.request(`/api/tenants/${tenantId}/import/apply`, {
+        method: "POST",
+        body: form
+      });
+    }
+    return this.request(`/api/tenants/${tenantId}/import/apply`, {
+      method: "POST",
+      body: JSON.stringify({ bundle: source.bundle, resolutions })
+    });
+  }
+};
+
 // src/client.ts
 var _Client = class extends AbstractClient {
   /**
@@ -2974,6 +3221,7 @@ var _Client = class extends AbstractClient {
       ...this.config.headers
     };
     this.resources = new ResourcesClient(this.config.baseURL, () => this.getAllHeaders());
+    this.exportImport = new ExportImportClient(this.config, () => this.getAllHeaders());
   }
   /**
    * Helper method to handle fetch responses and errors
@@ -3734,9 +3982,14 @@ var WorkspaceClient = class {
     });
   }
   // ==================== Project CRUD ====================
-  async listProjects(workspaceId) {
+  async listProjects(workspaceId, kind) {
+    const params = new URLSearchParams();
+    if (kind) {
+      params.set("kind", kind);
+    }
+    const qs = params.toString();
     const response = await this.request(
-      `/api/workspaces/${workspaceId}/projects`
+      `/api/workspaces/${workspaceId}/projects${qs ? `?${qs}` : ""}`
     );
     return response.data || [];
   }
@@ -3875,97 +4128,6 @@ 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
 import { parse } from "best-effort-json-parser";
 function createSimpleMessageMerger() {