@kalera/munin-sdk 0.1.0 → 1.0.1

package/.turbo/turbo-build.log

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

package/dist/client.d.ts

@@ -2,19 +2,24 @@ import type { MuninAction, MuninCapabilities, MuninClientConfig, MuninResponse }
 export declare class MuninClient {
     private readonly baseUrl;
     private readonly apiKey?;
-    private readonly project;
     private readonly timeoutMs;
     private readonly fetchImpl;
     private capabilitiesCache?;
-    constructor(config: MuninClientConfig);
+    constructor(config?: MuninClientConfig);
     capabilities(forceRefresh?: boolean): Promise<MuninCapabilities>;
-    invoke<TPayload extends Record<string, unknown>, TData = unknown>(action: MuninAction, payload: TPayload, options?: {
+    invoke<TPayload extends Record<string, unknown>, TData = unknown>(projectId: string, action: MuninAction, payload: TPayload, options?: {
         requestId?: string;
         ensureCapability?: boolean;
     }): Promise<MuninResponse<TData>>;
-    store(payload: Record<string, unknown>): Promise<MuninResponse<unknown>>;
-    retrieve(payload: Record<string, unknown>): Promise<MuninResponse<unknown>>;
-    search(payload: Record<string, unknown>): Promise<MuninResponse<unknown>>;
-    list(payload?: Record<string, unknown>): Promise<MuninResponse<unknown>>;
-    recent(payload?: Record<string, unknown>): Promise<MuninResponse<unknown>>;
+    /**
+     * Cleans up raw Munin response for LLM context efficiency.
+     * Removes dense vector arrays and formats GraphRAG objects into readable structures.
+     */
+    private formatLlmResponse;
+    private formatGraph;
+    store(projectId: string, payload: Record<string, unknown>): Promise<MuninResponse<unknown>>;
+    retrieve(projectId: string, payload: Record<string, unknown>): Promise<MuninResponse<unknown>>;
+    search(projectId: string, payload: Record<string, unknown>): Promise<MuninResponse<unknown>>;
+    list(projectId: string, payload?: Record<string, unknown>): Promise<MuninResponse<unknown>>;
+    recent(projectId: string, payload?: Record<string, unknown>): Promise<MuninResponse<unknown>>;
 }

package/dist/client.js

@@ -4,16 +4,14 @@ const DEFAULT_TIMEOUT_MS = 15_000;
 export class MuninClient {
     baseUrl;
     apiKey;
-    project;
     timeoutMs;
     fetchImpl;
     capabilitiesCache;
     constructor(config) {
-        this.baseUrl = config.baseUrl.replace(/\/$/, "");
-        this.apiKey = config.apiKey;
-        this.project = config.project;
-        this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-        this.fetchImpl = config.fetchImpl ?? fetch;
+        this.baseUrl = (config?.baseUrl || "https://munin.kalera.dev").replace(/\/$/, "");
+        this.apiKey = config?.apiKey;
+        this.timeoutMs = config?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.fetchImpl = config?.fetchImpl ?? fetch;
     }
     async capabilities(forceRefresh = false) {
         if (this.capabilitiesCache && !forceRefresh) {
@@ -23,7 +21,7 @@ export class MuninClient {
         this.capabilitiesCache = caps;
         return caps;
     }
-    async invoke(action, payload, options) {
+    async invoke(projectId, action, payload, options) {
         if (options?.ensureCapability) {
             const caps = await this.capabilities();
             if (!isActionSupported(caps, action)) {
@@ -35,13 +33,14 @@ export class MuninClient {
         }
         const request = {
             apiKey: this.apiKey,
-            projectId: this.project,
+            project: projectId,
+            projectId: projectId, // Fallback for un-restarted server
             action,
             payload,
             requestId: options?.requestId,
             client: {
                 name: "@kalera/munin-sdk",
-                version: "0.1.0",
+                version: "1.0.0",
             },
         };
         const controller = new AbortController();
@@ -59,26 +58,79 @@ export class MuninClient {
         clearTimeout(timeout);
         const body = (await response.json());
         if (!response.ok || (body.ok === false) || (body.success === false)) {
-            throw new MuninSdkError(body.error ?? {
+            let errObj = body.error;
+            if (typeof errObj === 'string') {
+                errObj = { code: "INTERNAL_ERROR", message: errObj };
+            }
+            throw new MuninSdkError(errObj ?? {
                 code: "INTERNAL_ERROR",
                 message: `Unexpected failure invoking action '${action}'`,
             });
         }
-        return body;
+        return this.formatLlmResponse(body);
+    }
+    /**
+     * Cleans up raw Munin response for LLM context efficiency.
+     * Removes dense vector arrays and formats GraphRAG objects into readable structures.
+     */
+    formatLlmResponse(rawRes) {
+        if (!rawRes || !rawRes.data)
+            return rawRes;
+        const data = rawRes.data;
+        // Clean single memory retrieve
+        if (data.key && data.content) {
+            if (data.embedding)
+                delete data.embedding;
+            if (data.knowledge_graph) {
+                data.knowledge_graph = this.formatGraph(data.knowledge_graph);
+            }
+        }
+        // Clean search/list/recent results
+        if (Array.isArray(data.results)) {
+            data.results = data.results.map((mem) => {
+                if (mem.embedding)
+                    delete mem.embedding;
+                return mem;
+            });
+        }
+        // Clean graph in search
+        if (data.knowledge_graph) {
+            data.knowledge_graph = this.formatGraph(data.knowledge_graph);
+        }
+        return rawRes;
+    }
+    formatGraph(kg) {
+        if (!kg)
+            return kg;
+        const entities = (kg.entities || []).map((e) => {
+            if (e.embedding)
+                delete e.embedding;
+            return `${e.name} (${e.type}): ${e.description}`;
+        });
+        const relationships = (kg.relationships || []).map((r) => {
+            if (r.embedding)
+                delete r.embedding;
+            return `${r.source} -[${r.relation}]-> ${r.target}`;
+        });
+        return {
+            summary: "GraphRAG knowledge formatted for readability",
+            entities,
+            relationships
+        };
     }
-    async store(payload) {
-        return this.invoke("store", payload, { ensureCapability: true });
+    async store(projectId, payload) {
+        return this.invoke(projectId, "store", payload, { ensureCapability: true });
     }
-    async retrieve(payload) {
-        return this.invoke("retrieve", payload, { ensureCapability: true });
+    async retrieve(projectId, payload) {
+        return this.invoke(projectId, "retrieve", payload, { ensureCapability: true });
     }
-    async search(payload) {
-        return this.invoke("search", payload, { ensureCapability: true });
+    async search(projectId, payload) {
+        return this.invoke(projectId, "search", payload, { ensureCapability: true });
     }
-    async list(payload = {}) {
-        return this.invoke("list", payload, { ensureCapability: true });
+    async list(projectId, payload = {}) {
+        return this.invoke(projectId, "list", payload, { ensureCapability: true });
     }
-    async recent(payload = {}) {
-        return this.invoke("recent", payload, { ensureCapability: true });
+    async recent(projectId, payload = {}) {
+        return this.invoke(projectId, "recent", payload, { ensureCapability: true });
     }
 }

package/dist/types.d.ts

@@ -37,9 +37,8 @@ export interface MuninResponse<TData = unknown> {
     requestId?: string;
 }
 export interface MuninClientConfig {
-    baseUrl: string;
+    baseUrl?: string;
     apiKey?: string;
-    project: string;
     timeoutMs?: number;
     fetchImpl?: typeof fetch;
 }

package/package.json

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

package/src/client.ts

@@ -16,17 +16,15 @@ const DEFAULT_TIMEOUT_MS = 15_000;
 export class MuninClient {
   private readonly baseUrl: string;
   private readonly apiKey?: string;
-  private readonly project: string;
   private readonly timeoutMs: number;
   private readonly fetchImpl: typeof fetch;
   private capabilitiesCache?: MuninCapabilities;
 
-  constructor(config: MuninClientConfig) {
-    this.baseUrl = config.baseUrl.replace(/\/$/, "");
-    this.apiKey = config.apiKey;
-    this.project = config.project;
-    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    this.fetchImpl = config.fetchImpl ?? fetch;
+  constructor(config?: MuninClientConfig) {
+    this.baseUrl = (config?.baseUrl || "https://munin.kalera.dev").replace(/\/$/, "");
+    this.apiKey = config?.apiKey;
+    this.timeoutMs = config?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.fetchImpl = config?.fetchImpl ?? fetch;
   }
 
   async capabilities(forceRefresh = false): Promise<MuninCapabilities> {
@@ -44,6 +42,7 @@ export class MuninClient {
   }
 
   async invoke<TPayload extends Record<string, unknown>, TData = unknown>(
+    projectId: string,
     action: MuninAction,
     payload: TPayload,
     options?: { requestId?: string; ensureCapability?: boolean },
@@ -60,13 +59,14 @@ export class MuninClient {
 
     const request = {
       apiKey: this.apiKey,
-      projectId: this.project,
+      project: projectId,
+      projectId: projectId, // Fallback for un-restarted server
       action,
       payload,
       requestId: options?.requestId,
       client: {
         name: "@kalera/munin-sdk",
-        version: "0.1.0",
+        version: "1.0.0",
       },
     };
 
@@ -91,34 +91,92 @@ export class MuninClient {
     const body = (await response.json()) as any;
 
     if (!response.ok || (body.ok === false) || (body.success === false)) {
+      let errObj = body.error;
+      if (typeof errObj === 'string') {
+        errObj = { code: "INTERNAL_ERROR", message: errObj };
+      }
+      
       throw new MuninSdkError(
-        body.error ?? {
+        errObj ?? {
           code: "INTERNAL_ERROR",
           message: `Unexpected failure invoking action '${action}'`,
         },
       );
     }
 
-    return body;
+    return this.formatLlmResponse(body);
+  }
+
+  /**
+   * Cleans up raw Munin response for LLM context efficiency.
+   * Removes dense vector arrays and formats GraphRAG objects into readable structures.
+   */
+  private formatLlmResponse(rawRes: any): any {
+    if (!rawRes || !rawRes.data) return rawRes;
+
+    const data = rawRes.data;
+
+    // Clean single memory retrieve
+    if (data.key && data.content) {
+      if (data.embedding) delete data.embedding;
+      if (data.knowledge_graph) {
+        data.knowledge_graph = this.formatGraph(data.knowledge_graph);
+      }
+    }
+
+    // Clean search/list/recent results
+    if (Array.isArray(data.results)) {
+      data.results = data.results.map((mem: any) => {
+        if (mem.embedding) delete mem.embedding;
+        return mem;
+      });
+    }
+
+    // Clean graph in search
+    if (data.knowledge_graph) {
+      data.knowledge_graph = this.formatGraph(data.knowledge_graph);
+    }
+
+    return rawRes;
+  }
+
+  private formatGraph(kg: any): any {
+    if (!kg) return kg;
+    
+    const entities = (kg.entities || []).map((e: any) => {
+      if (e.embedding) delete e.embedding;
+      return `${e.name} (${e.type}): ${e.description}`;
+    });
+
+    const relationships = (kg.relationships || []).map((r: any) => {
+      if (r.embedding) delete r.embedding;
+      return `${r.source} -[${r.relation}]-> ${r.target}`;
+    });
+
+    return {
+      summary: "GraphRAG knowledge formatted for readability",
+      entities,
+      relationships
+    };
   }
 
-  async store(payload: Record<string, unknown>) {
-    return this.invoke("store", payload, { ensureCapability: true });
+  async store(projectId: string, payload: Record<string, unknown>) {
+    return this.invoke(projectId, "store", payload, { ensureCapability: true });
   }
 
-  async retrieve(payload: Record<string, unknown>) {
-    return this.invoke("retrieve", payload, { ensureCapability: true });
+  async retrieve(projectId: string, payload: Record<string, unknown>) {
+    return this.invoke(projectId, "retrieve", payload, { ensureCapability: true });
   }
 
-  async search(payload: Record<string, unknown>) {
-    return this.invoke("search", payload, { ensureCapability: true });
+  async search(projectId: string, payload: Record<string, unknown>) {
+    return this.invoke(projectId, "search", payload, { ensureCapability: true });
   }
 
-  async list(payload: Record<string, unknown> = {}) {
-    return this.invoke("list", payload, { ensureCapability: true });
+  async list(projectId: string, payload: Record<string, unknown> = {}) {
+    return this.invoke(projectId, "list", payload, { ensureCapability: true });
   }
 
-  async recent(payload: Record<string, unknown> = {}) {
-    return this.invoke("recent", payload, { ensureCapability: true });
+  async recent(projectId: string, payload: Record<string, unknown> = {}) {
+    return this.invoke(projectId, "recent", payload, { ensureCapability: true });
   }
 }

package/src/types.ts

@@ -55,9 +55,8 @@ export interface MuninResponse<TData = unknown> {
 }
 
 export interface MuninClientConfig {
-  baseUrl: string;
+  baseUrl?: string;
   apiKey?: string;
-  project: string;
   timeoutMs?: number;
   fetchImpl?: typeof fetch;
 }

package/test/client.test.ts

@@ -47,14 +47,13 @@ async function run() {
 
   const client = new MuninClient({
     baseUrl: "http://localhost:4000",
-    project: "default",
     fetchImpl: fakeFetch,
   });
 
   const capabilities = await client.capabilities();
   assert.equal(capabilities.specVersion, "v1.0.0");
 
-  const result = await client.store({ key: "hello", content: "world" });
+  const result = await client.store("default", { key: "hello", content: "world" });
   assert.equal(result.ok, true);
   assert.equal((result.data as any).echoedAction, "store");