@kalera/munin-sdk 1.2.5 → 1.2.8

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @kalera/munin-sdk@1.2.5 build /home/runner/work/munin-for-agents/munin-for-agents/packages/ts-sdk
+> @kalera/munin-sdk@1.2.8 build /home/runner/work/munin-for-agents/munin-for-agents/packages/ts-sdk
 > tsc -p tsconfig.json
 

package/dist/client.d.ts

@@ -1,12 +1,11 @@
-import type { MuninAction, MuninCapabilities, MuninClientConfig, MuninResponse } from "./types.js";
+import type { MuninAction, MuninClientConfig, MuninResponse } from "./types.js";
 export declare class MuninClient {
     private readonly baseUrl;
     private readonly apiKey?;
     private readonly timeoutMs;
     private readonly fetchImpl;
-    private capabilitiesCache?;
     constructor(config?: MuninClientConfig);
-    capabilities(forceRefresh?: boolean): Promise<MuninCapabilities>;
+    capabilities(forceRefresh?: boolean): Promise<import("./types.js").MuninCapabilities>;
     invoke<TPayload extends Record<string, unknown>, TData = unknown>(projectId: string, action: MuninAction, payload: TPayload, options?: {
         requestId?: string;
         ensureCapability?: boolean;

package/dist/client.js

@@ -1,12 +1,11 @@
 import { MuninSdkError, MuninTransportError } from "./errors.js";
-import { fetchCapabilities, isActionSupported, } from "./capabilities.js";
+import { fetchCapabilities, isActionSupported } from "./capabilities.js";
 const DEFAULT_TIMEOUT_MS = 15_000;
 export class MuninClient {
     baseUrl;
     apiKey;
     timeoutMs;
     fetchImpl;
-    capabilitiesCache;
     constructor(config) {
         this.baseUrl = (config?.baseUrl || "https://munin.kalera.dev").replace(/\/$/, "");
         this.apiKey = config?.apiKey;
@@ -14,11 +13,11 @@ export class MuninClient {
         this.fetchImpl = config?.fetchImpl ?? fetch;
     }
     async capabilities(forceRefresh = false) {
-        if (this.capabilitiesCache && !forceRefresh) {
-            return this.capabilitiesCache;
+        if (!forceRefresh && globalThis.__munin_caps) {
+            return globalThis.__munin_caps;
         }
         const caps = await fetchCapabilities(this.baseUrl, this.apiKey, this.fetchImpl);
-        this.capabilitiesCache = caps;
+        globalThis.__munin_caps = caps;
         return caps;
     }
     async invoke(projectId, action, payload, options) {
@@ -31,41 +30,53 @@ export class MuninClient {
                 });
             }
         }
-        const request = {
-            apiKey: this.apiKey,
-            project: projectId,
-            projectId: projectId, // Fallback for un-restarted server
-            action,
-            payload,
-            requestId: options?.requestId,
-            client: {
-                name: "@kalera/munin-sdk",
-                version: "1.0.0",
-            },
-        };
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
-        const response = await this.fetchImpl(`${this.baseUrl}/api/mcp/action`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify(request),
-            signal: controller.signal,
-        }).catch((error) => {
+        let response;
+        try {
+            response = await this.fetchImpl(`${this.baseUrl}/api/mcp/action`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}),
+                },
+                body: JSON.stringify({
+                    action,
+                    project: projectId,
+                    projectId, // Fallback for un-restarted server
+                    payload,
+                    requestId: options?.requestId,
+                    client: {
+                        name: "@kalera/munin-sdk",
+                        version: "1.0.0",
+                    },
+                }),
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            clearTimeout(timeout);
             throw new MuninTransportError(`Request failed for action '${action}': ${String(error)}`);
-        });
+        }
         clearTimeout(timeout);
-        const body = (await response.json());
-        if (!response.ok || (body.ok === false) || (body.success === false)) {
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch {
+            throw new MuninTransportError(`Invalid JSON response for action '${action}'`);
+        }
+        if (!response.ok || !isResponseOk(body)) {
             let errObj = body.error;
-            if (typeof errObj === 'string') {
+            if (typeof errObj === "string") {
                 errObj = { code: "INTERNAL_ERROR", message: errObj };
             }
-            throw new MuninSdkError(errObj ?? {
-                code: "INTERNAL_ERROR",
-                message: `Unexpected failure invoking action '${action}'`,
-            });
+            throw new MuninSdkError((typeof errObj === "object" && errObj !== null && "code" in errObj && "message" in errObj)
+                ? errObj
+                : {
+                    code: "INTERNAL_ERROR",
+                    message: `Unexpected failure invoking action '${action}'`,
+                });
         }
         return body;
     }
@@ -88,3 +99,10 @@ export class MuninClient {
         return this.invoke(projectId, "share", { memoryIds, targetProjectIds }, { ensureCapability: true });
     }
 }
+/** Narrow a raw JSON value to a response-like object. */
+function isResponseOk(body) {
+    if (typeof body !== "object" || body === null)
+        return false;
+    const obj = body;
+    return obj.ok === true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kalera/munin-sdk",
-  "version": "1.2.5",
+  "version": "1.2.8",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/client.ts

@@ -1,12 +1,7 @@
 import { MuninSdkError, MuninTransportError } from "./errors.js";
-import {
-  fetchCapabilities,
-  isActionSupported,
-} from "./capabilities.js";
+import { fetchCapabilities, isActionSupported } from "./capabilities.js";
 import type {
   MuninAction,
-  MuninActionEnvelope,
-  MuninCapabilities,
   MuninClientConfig,
   MuninResponse,
 } from "./types.js";
@@ -18,7 +13,6 @@ export class MuninClient {
   private readonly apiKey?: string;
   private readonly timeoutMs: number;
   private readonly fetchImpl: typeof fetch;
-  private capabilitiesCache?: MuninCapabilities;
 
   constructor(config?: MuninClientConfig) {
     this.baseUrl = (config?.baseUrl || "https://munin.kalera.dev").replace(/\/$/, "");
@@ -27,17 +21,12 @@ export class MuninClient {
     this.fetchImpl = config?.fetchImpl ?? fetch;
   }
 
-  async capabilities(forceRefresh = false): Promise<MuninCapabilities> {
-    if (this.capabilitiesCache && !forceRefresh) {
-      return this.capabilitiesCache;
+  async capabilities(forceRefresh = false) {
+    if (!forceRefresh && (globalThis as Record<string, unknown>).__munin_caps) {
+      return (globalThis as Record<string, unknown>).__munin_caps as Awaited<ReturnType<typeof fetchCapabilities>>;
     }
-
-    const caps = await fetchCapabilities(
-      this.baseUrl,
-      this.apiKey,
-      this.fetchImpl,
-    );
-    this.capabilitiesCache = caps;
+    const caps = await fetchCapabilities(this.baseUrl, this.apiKey, this.fetchImpl);
+    (globalThis as Record<string, unknown>).__munin_caps = caps;
     return caps;
   }
 
@@ -57,77 +46,99 @@ export class MuninClient {
       }
     }
 
-    const request = {
-      apiKey: this.apiKey,
-      project: projectId,
-      projectId: projectId, // Fallback for un-restarted server
-      action,
-      payload,
-      requestId: options?.requestId,
-      client: {
-        name: "@kalera/munin-sdk",
-        version: "1.0.0",
-      },
-    };
-
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
 
-    const response = await this.fetchImpl(`${this.baseUrl}/api/mcp/action`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(request),
-      signal: controller.signal,
-    }).catch((error: unknown) => {
+    let response: Response;
+    try {
+      response = await this.fetchImpl(`${this.baseUrl}/api/mcp/action`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...(this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}),
+        },
+        body: JSON.stringify({
+          action,
+          project: projectId,
+          projectId, // Fallback for un-restarted server
+          payload,
+          requestId: options?.requestId,
+          client: {
+            name: "@kalera/munin-sdk",
+            version: "1.0.0",
+          },
+        }),
+        signal: controller.signal,
+      });
+    } catch (error) {
+      clearTimeout(timeout);
       throw new MuninTransportError(
         `Request failed for action '${action}': ${String(error)}`,
       );
-    });
+    }
 
     clearTimeout(timeout);
 
-    const body = (await response.json()) as any;
+    let body: unknown;
+    try {
+      body = await response.json();
+    } catch {
+      throw new MuninTransportError(
+        `Invalid JSON response for action '${action}'`,
+      );
+    }
 
-    if (!response.ok || (body.ok === false) || (body.success === false)) {
-      let errObj = body.error;
-      if (typeof errObj === 'string') {
+    if (!response.ok || !isResponseOk(body)) {
+      let errObj = (body as Record<string, unknown>).error;
+      if (typeof errObj === "string") {
         errObj = { code: "INTERNAL_ERROR", message: errObj };
       }
-      
+
       throw new MuninSdkError(
-        errObj ?? {
-          code: "INTERNAL_ERROR",
-          message: `Unexpected failure invoking action '${action}'`,
-        },
+        (typeof errObj === "object" && errObj !== null && "code" in errObj && "message" in errObj)
+          ? (errObj as { code: "AUTH_INVALID" | "FEATURE_DISABLED" | "NOT_FOUND" | "RATE_LIMITED" | "VALIDATION_ERROR" | "INTERNAL_ERROR"; message: string })
+          : {
+            code: "INTERNAL_ERROR" as const,
+            message: `Unexpected failure invoking action '${action}'`,
+          },
       );
     }
 
-    return body;
+    return body as MuninResponse<TData>;
   }
 
-  async store(projectId: string, payload: Record<string, unknown>) {
+  async store(projectId: string, payload: Record<string, unknown>): Promise<MuninResponse<unknown>> {
     return this.invoke(projectId, "store", payload, { ensureCapability: true });
   }
 
-  async retrieve(projectId: string, payload: Record<string, unknown>) {
+  async retrieve(projectId: string, payload: Record<string, unknown>): Promise<MuninResponse<unknown>> {
     return this.invoke(projectId, "retrieve", payload, { ensureCapability: true });
   }
 
-  async search(projectId: string, payload: Record<string, unknown>) {
+  async search(projectId: string, payload: Record<string, unknown>): Promise<MuninResponse<unknown>> {
     return this.invoke(projectId, "search", payload, { ensureCapability: true });
   }
 
-  async list(projectId: string, payload: Record<string, unknown> = {}) {
+  async list(projectId: string, payload: Record<string, unknown> = {}): Promise<MuninResponse<unknown>> {
     return this.invoke(projectId, "list", payload, { ensureCapability: true });
   }
 
-  async recent(projectId: string, payload: Record<string, unknown> = {}) {
+  async recent(projectId: string, payload: Record<string, unknown> = {}): Promise<MuninResponse<unknown>> {
     return this.invoke(projectId, "recent", payload, { ensureCapability: true });
   }
 
-  async share(projectId: string, memoryIds: string[], targetProjectIds: string[]) {
+  async share(
+    projectId: string,
+    memoryIds: string[],
+    targetProjectIds: string[],
+  ): Promise<MuninResponse<unknown>> {
     return this.invoke(projectId, "share", { memoryIds, targetProjectIds }, { ensureCapability: true });
   }
 }
+
+/** Narrow a raw JSON value to a response-like object. */
+function isResponseOk(body: unknown): boolean {
+  if (typeof body !== "object" || body === null) return false;
+  const obj = body as Record<string, unknown>;
+  return obj.ok === true;
+}