@meshagent/meshagent-ts-auth 0.38.2 → 0.38.4

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.38.4]
+- Stability
+
+## [0.38.3]
+- Breaking: TypeScript container image summaries now use `references`/`preferredRef` and metadata fields (timestamps/media type), and `inspectImage` returns manifests/layers/content size; `tags`/`size` are removed.
+- `getUsage` now supports filters for users, room, provider, model, and usage type.
+- Room connection and errors improved: `RoomServerException` now carries `statusCode` and `retryable`, and `RoomClient` can route OAuth/secret requests via handler options.
+- React hooks add robust connection retry/backoff, new authorization helpers, and optional secret/OAuth handlers; document connection now supports schema/initial JSON and improved cleanup.
+- New Livekit support (client + protocol channel) and room participant hook; hosted toolkits are now shared per room to avoid duplicate starts.
+- Breaking: `meshagent-react` no longer exports the legacy chat and file-upload modules.
+- Tailwind chat UI is rebuilt with multi-thread support, new thread creation via agent tools, and file attachment utilities, with new exports for thread and conversation helpers.
+
 ## [0.38.2]
 - Stability
 

package/dist/browser/ma-auth.global.js

@@ -9880,10 +9880,12 @@ ${err.toString()}`);
 
   // ../meshagent-ts/dist/esm/room-server-client.js
   var RoomServerException = class extends Error {
-    constructor(message, code) {
+    constructor(message, code, { statusCode, retryable = false } = {}) {
       super(message);
       this.name = "RoomServerException";
+      this.statusCode = statusCode;
       this.code = code;
+      this.retryable = retryable;
     }
   };
   var MeshDocument = class extends RuntimeDocument {
@@ -10360,6 +10362,30 @@ ${err.toString()}`);
     }
     return value;
   }
+  function readOptionalStringField(data, field, operation) {
+    const value = data[field];
+    if (value === void 0 || value === null) {
+      return void 0;
+    }
+    if (typeof value !== "string") {
+      throw new RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    return value;
+  }
+  function parseTimestampField(data, field, operation) {
+    const value = data[field];
+    if (value === void 0 || value === null) {
+      return void 0;
+    }
+    if (typeof value !== "string") {
+      throw new RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    const timestamp = new Date(value);
+    if (Number.isNaN(timestamp.getTime())) {
+      throw new RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    return timestamp;
+  }
   function decodeUtf8(data, operation) {
     try {
       return new TextDecoder("utf-8", { fatal: true }).decode(data);
@@ -10415,6 +10441,98 @@ ${err.toString()}`);
     }
     throw new RoomServerException(`unexpected return type from containers.${operation}`);
   }
+  function normalizeImageReferences(entry, operation) {
+    const referencesRaw = entry["references"];
+    if (Array.isArray(referencesRaw)) {
+      const references = referencesRaw.filter((item) => typeof item === "string");
+      if (references.length !== referencesRaw.length) {
+        throw new RoomServerException(`unexpected return type from containers.${operation}`);
+      }
+      return references;
+    }
+    const tagsRaw = entry["tags"];
+    if (Array.isArray(tagsRaw)) {
+      const references = tagsRaw.filter((item) => typeof item === "string");
+      if (references.length !== tagsRaw.length) {
+        throw new RoomServerException(`unexpected return type from containers.${operation}`);
+      }
+      return references;
+    }
+    if (referencesRaw === void 0 || referencesRaw === null) {
+      return [];
+    }
+    throw new RoomServerException(`unexpected return type from containers.${operation}`);
+  }
+  function parseContainerImage(entry, operation) {
+    const references = normalizeImageReferences(entry, operation);
+    const preferredRef = readOptionalStringField(entry, "preferred_ref", operation) ?? references[0];
+    return {
+      id: readStringField(entry, "id", operation),
+      preferredRef,
+      references,
+      labels: normalizeImageLabels(entry["labels"], operation),
+      createdAt: parseTimestampField(entry, "created_at", operation),
+      updatedAt: parseTimestampField(entry, "updated_at", operation),
+      targetMediaType: readOptionalStringField(entry, "target_media_type", operation)
+    };
+  }
+  function parseContainerImageDescriptor(entry, operation) {
+    return {
+      digest: readStringField(entry, "digest", operation),
+      mediaType: readOptionalStringField(entry, "media_type", operation),
+      size: readOptionalIntegerField(entry, "size", operation),
+      annotations: normalizeImageLabels(entry["annotations"], operation)
+    };
+  }
+  function parseOptionalContainerImageDescriptor(value, operation) {
+    if (value === void 0 || value === null) {
+      return void 0;
+    }
+    if (!isRecord2(value)) {
+      throw new RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    return parseContainerImageDescriptor(value, operation);
+  }
+  function parseContainerImageManifest(entry, operation) {
+    const descriptorRaw = entry["descriptor"];
+    if (!isRecord2(descriptorRaw)) {
+      throw new RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    return {
+      descriptor: parseContainerImageDescriptor(descriptorRaw, operation),
+      platformOs: readOptionalStringField(entry, "platform_os", operation),
+      platformArchitecture: readOptionalStringField(entry, "platform_architecture", operation),
+      platformVariant: readOptionalStringField(entry, "platform_variant", operation)
+    };
+  }
+  function parseContainerImageInspection(entry, operation) {
+    const imageRaw = entry["image"];
+    const targetRaw = entry["target"];
+    const manifestsRaw = entry["manifests"];
+    const layersRaw = entry["layers"];
+    if (!isRecord2(imageRaw) || !isRecord2(targetRaw) || !Array.isArray(manifestsRaw) || !Array.isArray(layersRaw)) {
+      throw new RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    return {
+      image: parseContainerImage(imageRaw, operation),
+      target: parseContainerImageDescriptor(targetRaw, operation),
+      selectedManifest: parseOptionalContainerImageDescriptor(entry["selected_manifest"], operation),
+      manifests: manifestsRaw.map((manifest) => {
+        if (!isRecord2(manifest)) {
+          throw new RoomServerException(`unexpected return type from containers.${operation}`);
+        }
+        return parseContainerImageManifest(manifest, operation);
+      }),
+      config: parseOptionalContainerImageDescriptor(entry["config"], operation),
+      layers: layersRaw.map((layer) => {
+        if (!isRecord2(layer)) {
+          throw new RoomServerException(`unexpected return type from containers.${operation}`);
+        }
+        return parseContainerImageDescriptor(layer, operation);
+      }),
+      contentSize: readOptionalIntegerField(entry, "content_size", operation)
+    };
+  }
   function parseImportedImage(data, operation) {
     const resolvedRef = data["resolved_ref"];
     const refsRaw = data["refs"];
@@ -10608,23 +10726,19 @@ ${err.toString()}`);
         if (!isRecord2(entry)) {
           throw this.unexpectedResponseError("list_images");
         }
-        const id2 = entry["id"];
-        const tags = entry["tags"];
-        const labelsRaw = entry["labels"];
-        if (typeof id2 !== "string" || !Array.isArray(tags)) {
-          throw this.unexpectedResponseError("list_images");
-        }
-        const normalizedTags = tags.filter((tag) => typeof tag === "string");
-        const size2 = entry["size"];
-        images.push({
-          id: id2,
-          tags: normalizedTags,
-          size: typeof size2 === "number" ? size2 : void 0,
-          labels: normalizeImageLabels(labelsRaw, "list_images")
-        });
+        images.push(parseContainerImage(entry, "list_images"));
       }
       return images;
     }
+    async inspectImage(params2) {
+      const output = await this.invoke("inspect_image", {
+        image_id: params2.imageId
+      });
+      if (!(output instanceof JsonContent) || !isRecord2(output.json)) {
+        throw this.unexpectedResponseError("inspect_image");
+      }
+      return parseContainerImageInspection(output.json, "inspect_image");
+    }
     async deleteImage(params2) {
       await this.invoke("delete_image", {
         image: params2.image
@@ -14857,13 +14971,18 @@ ${err.toString()}`);
       });
     }
     async getUsage(projectId, options = {}) {
-      const { start, end, interval, report } = options;
+      const { start, end, interval, report, users, room, provider, model, usageType } = options;
       const data = await this.request(`/accounts/projects/${projectId}/usage`, {
         query: {
           start: start ? start.toISOString() : void 0,
           end: end ? end.toISOString() : void 0,
           interval,
-          report
+          report,
+          users: users && users.length > 0 ? users.join(",") : void 0,
+          room: room && room.trim().length > 0 ? room.trim() : void 0,
+          provider: provider && provider.trim().length > 0 ? provider.trim() : void 0,
+          model: model && model.trim().length > 0 ? model.trim() : void 0,
+          usage_type: usageType && usageType.trim().length > 0 ? usageType.trim() : void 0
         },
         action: "retrieve usage"
       });
@@ -18133,7 +18252,7 @@ ${err.toString()}`);
     }
   };
   var RoomClient = class _RoomClient {
-    constructor({ protocolFactory = null, reconnectTimeout = null } = {}) {
+    constructor({ protocolFactory = null, reconnectTimeout = null, oauthTokenRequestHandler, secretRequestHandler } = {}) {
       this._entered = false;
       this._allowDisconnectedRequests = false;
       this._eventsController = new StreamController();
@@ -18180,7 +18299,11 @@ ${err.toString()}`);
       this.queues = new QueuesClient({ room: this });
       this.database = new DatabaseClient({ room: this });
       this.agents = new AgentsClient({ room: this });
-      this.secrets = new SecretsClient({ room: this });
+      this.secrets = new SecretsClient({
+        room: this,
+        oauthTokenRequestHandler,
+        secretRequestHandler
+      });
       this.containers = new ContainersClient({ room: this });
       this.memory = new MemoryClient({ room: this });
       this.services = new ServicesClient({ room: this });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meshagent/meshagent-ts-auth",
-    "version": "0.38.2",
+    "version": "0.38.4",
     "description": "Meshagent Typescript Auth",
     "homepage": "https://github.com/meshagent/meshagent-ts-auth",
     "scripts": {
@@ -39,7 +39,7 @@
         "CHANGELOG.md"
     ],
     "dependencies": {
-        "@meshagent/meshagent": "^0.38.2",
+        "@meshagent/meshagent": "^0.38.4",
         "typescript": "^5.8.3"
     },
     "devDependencies": {