rice-node-sdk 1.0.2 → 1.0.3

package/dist/storage/client/BaseClient.d.ts

@@ -15,6 +15,7 @@ export interface SearchResultItem {
     id: Long;
     similarity: number;
     metadata: any;
+    data?: string;
 }
 export interface MemoryEntry {
     id: string;

package/dist/storage/client/GrpcClient.js

@@ -98,10 +98,15 @@ class GrpcClient extends BaseClient_1.BaseRiceDBClient {
     async insert(nodeId, text, metadata, userId = 1, sessionId, embedding) {
         if (!this.client)
             throw new Error("Not connected");
+        // Automatically store text in metadata so it can be retrieved
+        const meta = { ...metadata };
+        if (text && !meta.stored_text) {
+            meta.stored_text = text;
+        }
         const req = {
             id: this.toLong(nodeId),
             text,
-            metadata: Buffer.from(JSON.stringify(metadata)),
+            metadata: Buffer.from(JSON.stringify(meta)),
             userId: this.toLong(userId),
             sessionId,
             embedding: embedding || [],
@@ -121,11 +126,15 @@ class GrpcClient extends BaseClient_1.BaseRiceDBClient {
             queryEmbedding: queryEmbedding || [],
         };
         const res = await this.promisify(this.client.search, req);
-        return res.results.map((r) => ({
-            id: r.id,
-            similarity: r.similarity,
-            metadata: JSON.parse(r.metadata.toString()),
-        }));
+        return res.results.map((r) => {
+            const meta = JSON.parse(r.metadata.toString());
+            return {
+                id: r.id,
+                similarity: r.similarity,
+                metadata: meta,
+                data: meta.stored_text,
+            };
+        });
     }
     async delete(nodeId, sessionId) {
         if (!this.client)

package/dist/storage/client/HttpClient.js

@@ -40,7 +40,8 @@ class HttpClient extends BaseClient_1.BaseRiceDBClient {
     }
     setAuthHeader() {
         if (this.token) {
-            this.client.defaults.headers.common["Authorization"] = `Bearer ${this.token}`;
+            this.client.defaults.headers.common["Authorization"] =
+                `Bearer ${this.token}`;
         }
     }
     async request(method, url, data, params) {
@@ -79,10 +80,15 @@ class HttpClient extends BaseClient_1.BaseRiceDBClient {
         return this.request("GET", "/auth/users");
     }
     async insert(nodeId, text, metadata, userId = 1, sessionId, embedding) {
+        // Automatically store text in metadata so it can be retrieved
+        const meta = { ...metadata };
+        if (text && !meta.stored_text) {
+            meta.stored_text = text;
+        }
         const payload = {
             id: this.toLong(nodeId).toNumber(),
             text,
-            metadata,
+            metadata: meta,
             user_id: this.toLong(userId).toNumber(),
         };
         if (sessionId)
@@ -117,12 +123,16 @@ class HttpClient extends BaseClient_1.BaseRiceDBClient {
             id: long_1.default.fromValue(r.id),
             similarity: r.similarity,
             metadata: r.metadata,
+            data: r.metadata ? r.metadata.stored_text : undefined,
         }));
     }
     async delete(nodeId, sessionId) {
-        const params = {};
+        const params = {
+            node_id: this.toLong(nodeId).toNumber(), // Use number or string? Try number first as insert uses number
+        };
         if (sessionId)
             params.session_id = sessionId;
+        // Try /node/:id but include node_id in query params as well, as server seems to require it in query
         await this.request("DELETE", `/node/${this.toLong(nodeId).toString()}`, undefined, params);
         return true;
     }

package/dist/tools/anthropic.d.ts

@@ -9,6 +9,20 @@ export declare const state: ({
                 description: string;
             };
             query?: undefined;
+            name?: undefined;
+            value?: undefined;
+            source?: undefined;
+            description?: undefined;
+            priority?: undefined;
+            parentId?: undefined;
+            goalId?: undefined;
+            status?: undefined;
+            statusFilter?: undefined;
+            agentId?: undefined;
+            actionType?: undefined;
+            actionDetails?: undefined;
+            limit?: undefined;
+            actionTypeFilter?: undefined;
         };
         required: string[];
     };
@@ -23,7 +37,264 @@ export declare const state: ({
                 description: string;
             };
             content?: undefined;
+            name?: undefined;
+            value?: undefined;
+            source?: undefined;
+            description?: undefined;
+            priority?: undefined;
+            parentId?: undefined;
+            goalId?: undefined;
+            status?: undefined;
+            statusFilter?: undefined;
+            agentId?: undefined;
+            actionType?: undefined;
+            actionDetails?: undefined;
+            limit?: undefined;
+            actionTypeFilter?: undefined;
         };
         required: string[];
     };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            value: {
+                description: string;
+            };
+            source: {
+                type: string;
+                description: string;
+            };
+            content?: undefined;
+            query?: undefined;
+            description?: undefined;
+            priority?: undefined;
+            parentId?: undefined;
+            goalId?: undefined;
+            status?: undefined;
+            statusFilter?: undefined;
+            agentId?: undefined;
+            actionType?: undefined;
+            actionDetails?: undefined;
+            limit?: undefined;
+            actionTypeFilter?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            content?: undefined;
+            query?: undefined;
+            value?: undefined;
+            source?: undefined;
+            description?: undefined;
+            priority?: undefined;
+            parentId?: undefined;
+            goalId?: undefined;
+            status?: undefined;
+            statusFilter?: undefined;
+            agentId?: undefined;
+            actionType?: undefined;
+            actionDetails?: undefined;
+            limit?: undefined;
+            actionTypeFilter?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            content?: undefined;
+            query?: undefined;
+            name?: undefined;
+            value?: undefined;
+            source?: undefined;
+            description?: undefined;
+            priority?: undefined;
+            parentId?: undefined;
+            goalId?: undefined;
+            status?: undefined;
+            statusFilter?: undefined;
+            agentId?: undefined;
+            actionType?: undefined;
+            actionDetails?: undefined;
+            limit?: undefined;
+            actionTypeFilter?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            description: {
+                type: string;
+                description: string;
+            };
+            priority: {
+                type: string;
+                description: string;
+            };
+            parentId: {
+                type: string;
+                description: string;
+            };
+            content?: undefined;
+            query?: undefined;
+            name?: undefined;
+            value?: undefined;
+            source?: undefined;
+            goalId?: undefined;
+            status?: undefined;
+            statusFilter?: undefined;
+            agentId?: undefined;
+            actionType?: undefined;
+            actionDetails?: undefined;
+            limit?: undefined;
+            actionTypeFilter?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            goalId: {
+                type: string;
+                description: string;
+            };
+            status: {
+                type: string;
+                description: string;
+            };
+            content?: undefined;
+            query?: undefined;
+            name?: undefined;
+            value?: undefined;
+            source?: undefined;
+            description?: undefined;
+            priority?: undefined;
+            parentId?: undefined;
+            statusFilter?: undefined;
+            agentId?: undefined;
+            actionType?: undefined;
+            actionDetails?: undefined;
+            limit?: undefined;
+            actionTypeFilter?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            statusFilter: {
+                type: string;
+                description: string;
+            };
+            content?: undefined;
+            query?: undefined;
+            name?: undefined;
+            value?: undefined;
+            source?: undefined;
+            description?: undefined;
+            priority?: undefined;
+            parentId?: undefined;
+            goalId?: undefined;
+            status?: undefined;
+            agentId?: undefined;
+            actionType?: undefined;
+            actionDetails?: undefined;
+            limit?: undefined;
+            actionTypeFilter?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            agentId: {
+                type: string;
+                description: string;
+            };
+            actionType: {
+                type: string;
+                description: string;
+            };
+            actionDetails: {
+                description: string;
+            };
+            content?: undefined;
+            query?: undefined;
+            name?: undefined;
+            value?: undefined;
+            source?: undefined;
+            description?: undefined;
+            priority?: undefined;
+            parentId?: undefined;
+            goalId?: undefined;
+            status?: undefined;
+            statusFilter?: undefined;
+            limit?: undefined;
+            actionTypeFilter?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            limit: {
+                type: string;
+                description: string;
+            };
+            actionTypeFilter: {
+                type: string;
+                description: string;
+            };
+            content?: undefined;
+            query?: undefined;
+            name?: undefined;
+            value?: undefined;
+            source?: undefined;
+            description?: undefined;
+            priority?: undefined;
+            parentId?: undefined;
+            goalId?: undefined;
+            status?: undefined;
+            statusFilter?: undefined;
+            agentId?: undefined;
+            actionType?: undefined;
+            actionDetails?: undefined;
+        };
+        required?: undefined;
+    };
 })[];

package/dist/tools/anthropic.js

@@ -41,4 +41,152 @@ exports.state = [
             required: ["content"],
         },
     },
+    // Working Memory (Structured Variables)
+    {
+        name: "setVariable",
+        description: "Sets a structured variable in working memory.",
+        input_schema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "The name of the variable." },
+                value: {
+                    description: "The value to store (any JSON-serializable type).",
+                },
+                source: {
+                    type: "string",
+                    description: "Source of the variable: 'system', 'reasoning', 'retrieval', 'perception', or 'explicit'.",
+                },
+            },
+            required: ["name", "value"],
+        },
+    },
+    {
+        name: "getVariable",
+        description: "Gets a structured variable from working memory.",
+        input_schema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "The name of the variable to retrieve.",
+                },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "listVariables",
+        description: "Lists all variables in working memory.",
+        input_schema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "deleteVariable",
+        description: "Deletes a variable from working memory.",
+        input_schema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "The name of the variable to delete.",
+                },
+            },
+            required: ["name"],
+        },
+    },
+    // Goals
+    {
+        name: "addGoal",
+        description: "Adds a new goal to the agent's goal stack.",
+        input_schema: {
+            type: "object",
+            properties: {
+                description: {
+                    type: "string",
+                    description: "The description of the goal.",
+                },
+                priority: {
+                    type: "string",
+                    description: "Priority level: 'low', 'medium', 'high', or 'critical'.",
+                },
+                parentId: {
+                    type: "string",
+                    description: "Optional parent goal ID for hierarchical goals.",
+                },
+            },
+            required: ["description"],
+        },
+    },
+    {
+        name: "updateGoal",
+        description: "Updates the status of an existing goal.",
+        input_schema: {
+            type: "object",
+            properties: {
+                goalId: {
+                    type: "string",
+                    description: "The ID of the goal to update.",
+                },
+                status: {
+                    type: "string",
+                    description: "New status: 'active', 'suspended', 'achieved', 'abandoned', or 'failed'.",
+                },
+            },
+            required: ["goalId", "status"],
+        },
+    },
+    {
+        name: "listGoals",
+        description: "Lists all goals, optionally filtered by status.",
+        input_schema: {
+            type: "object",
+            properties: {
+                statusFilter: {
+                    type: "string",
+                    description: "Optional status to filter by.",
+                },
+            },
+        },
+    },
+    // Actions
+    {
+        name: "submitAction",
+        description: "Submits an action for execution and logging.",
+        input_schema: {
+            type: "object",
+            properties: {
+                agentId: {
+                    type: "string",
+                    description: "The ID of the agent submitting the action.",
+                },
+                actionType: {
+                    type: "string",
+                    description: "Type of action: 'reason', 'retrieve', 'learn', or 'ground'.",
+                },
+                actionDetails: {
+                    description: "The action details (any JSON-serializable object).",
+                },
+            },
+            required: ["agentId", "actionType", "actionDetails"],
+        },
+    },
+    {
+        name: "getActionLog",
+        description: "Gets the action log for the current run.",
+        input_schema: {
+            type: "object",
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Maximum number of entries to retrieve.",
+                },
+                actionTypeFilter: {
+                    type: "string",
+                    description: "Optional action type to filter by.",
+                },
+            },
+        },
+    },
 ];

package/dist/tools/execute.d.ts

@@ -1,2 +1,2 @@
 import { StateClient } from "../state";
-export declare function execute(name: string, args: any, client: StateClient): Promise<string | boolean | any[]>;
+export declare function execute(name: string, args: any, client: StateClient): Promise<any>;

package/dist/tools/execute.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.execute = execute;
 async function execute(name, args, client) {
     switch (name) {
+        // Core Memory Operations
         case "focus":
             return await client.focus(args.content);
         case "recall":
@@ -16,6 +17,27 @@ async function execute(name, args, client) {
             return await client.commit(args.input, args.outcome, {
                 action: args.action,
             });
+        // Working Memory (Structured Variables)
+        case "setVariable":
+            return await client.setVariable(args.name, args.value, args.source);
+        case "getVariable":
+            return await client.getVariable(args.name);
+        case "listVariables":
+            return await client.listVariables();
+        case "deleteVariable":
+            return await client.deleteVariable(args.name);
+        // Goals
+        case "addGoal":
+            return await client.addGoal(args.description, args.priority, args.parentId);
+        case "updateGoal":
+            return await client.updateGoal(args.goalId, args.status);
+        case "listGoals":
+            return await client.listGoals(args.statusFilter);
+        // Actions
+        case "submitAction":
+            return await client.submitAction(args.agentId, args.actionType, args.actionDetails);
+        case "getActionLog":
+            return await client.getActionLog(args.limit, args.actionTypeFilter);
         default:
             throw new Error(`Unknown tool: ${name}`);
     }