rice-node-sdk 1.0.0

package/dist/storage/utils/BitVector.d.ts

@@ -0,0 +1,10 @@
+import Long from "long";
+export declare class BitVector {
+    private chunks;
+    static readonly ADDRESS_SIZE_U64 = 16;
+    constructor(chunks?: Long[] | number[]);
+    static random(): BitVector;
+    toList(): Long[];
+    hammingDistance(other: BitVector): number;
+    private popCount32;
+}

package/dist/storage/utils/BitVector.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitVector = void 0;
+const long_1 = __importDefault(require("long"));
+class BitVector {
+    constructor(chunks) {
+        if (chunks) {
+            if (chunks.length !== BitVector.ADDRESS_SIZE_U64) {
+                throw new Error(`BitVector must have ${BitVector.ADDRESS_SIZE_U64} chunks`);
+            }
+            this.chunks = chunks.map((c) => long_1.default.fromValue(c));
+        }
+        else {
+            this.chunks = new Array(BitVector.ADDRESS_SIZE_U64).fill(long_1.default.UZERO);
+        }
+    }
+    static random() {
+        const chunks = [];
+        for (let i = 0; i < BitVector.ADDRESS_SIZE_U64; i++) {
+            // Generate random 64-bit int.
+            // random() returns [0, 1).
+            const low = Math.floor(Math.random() * 0x100000000);
+            const high = Math.floor(Math.random() * 0x100000000);
+            chunks.push(new long_1.default(low, high, true)); // unsigned
+        }
+        return new BitVector(chunks);
+    }
+    toList() {
+        return this.chunks;
+    }
+    hammingDistance(other) {
+        let distance = 0;
+        for (let i = 0; i < BitVector.ADDRESS_SIZE_U64; i++) {
+            const xor = this.chunks[i].xor(other.chunks[i]);
+            // Long stores values as signed 32-bit integers, but bitwise operations work on bits.
+            // getLowBits() and getHighBits() return signed 32-bit integers.
+            // We cast them to unsigned for bit counting logic if needed, but standard popcount works on bit pattern.
+            distance +=
+                this.popCount32(xor.getLowBits()) + this.popCount32(xor.getHighBits());
+        }
+        return distance;
+    }
+    // Hamming weight (population count) for 32-bit integer
+    popCount32(n) {
+        n = n - ((n >>> 1) & 0x55555555);
+        n = (n & 0x33333333) + ((n >>> 2) & 0x33333333);
+        return (((n + (n >>> 4)) & 0xf0f0f0f) * 0x1010101) >>> 24;
+    }
+}
+exports.BitVector = BitVector;
+BitVector.ADDRESS_SIZE_U64 = 16;

package/dist/tools/anthropic.d.ts

@@ -0,0 +1,29 @@
+export declare const state: ({
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            content: {
+                type: string;
+                description: string;
+            };
+            query?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            content?: undefined;
+        };
+        required: string[];
+    };
+})[];

package/dist/tools/anthropic.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.state = void 0;
+exports.state = [
+    {
+        name: "focus",
+        description: "Stores a piece of information in working memory (State/Flux).",
+        input_schema: {
+            type: "object",
+            properties: {
+                content: {
+                    type: "string",
+                    description: "The information to focus on.",
+                },
+            },
+            required: ["content"],
+        },
+    },
+    {
+        name: "recall",
+        description: "Recalls relevant memories from State based on a query.",
+        input_schema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "The query to search for." },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "remember",
+        description: "Stores information in long-term memory for future recall.",
+        input_schema: {
+            type: "object",
+            properties: {
+                content: {
+                    type: "string",
+                    description: "The information to remember.",
+                },
+            },
+            required: ["content"],
+        },
+    },
+];

package/dist/tools/execute.d.ts

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

package/dist/tools/execute.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+async function execute(name, args, client) {
+    switch (name) {
+        case "focus":
+            return await client.focus(args.content);
+        case "recall":
+            return await client.reminisce(args.query);
+        case "remember":
+            if (args.content) {
+                return await client.commit(args.content, "Stored in long-term memory", {
+                    action: "remember",
+                });
+            }
+            return await client.commit(args.input, args.outcome, {
+                action: args.action,
+            });
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}

package/dist/tools/google.d.ts

@@ -0,0 +1,29 @@
+export declare const state: ({
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            content: {
+                type: string;
+                description: string;
+            };
+            query?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            content?: undefined;
+        };
+        required: string[];
+    };
+})[];

package/dist/tools/google.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.state = void 0;
+exports.state = [
+    {
+        name: "focus",
+        description: "Stores a piece of information in working memory (State/Flux).",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                content: {
+                    type: "STRING",
+                    description: "The information to focus on.",
+                },
+            },
+            required: ["content"],
+        },
+    },
+    {
+        name: "recall",
+        description: "Recalls relevant memories from State based on a query.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                query: { type: "STRING", description: "The query to search for." },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "remember",
+        description: "Stores information in long-term memory for future recall.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                content: {
+                    type: "STRING",
+                    description: "The information to remember.",
+                },
+            },
+            required: ["content"],
+        },
+    },
+];

package/dist/tools/openai.d.ts

@@ -0,0 +1,35 @@
+export declare const state: ({
+    type: string;
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {
+                content: {
+                    type: string;
+                    description: string;
+                };
+                query?: undefined;
+            };
+            required: string[];
+        };
+    };
+} | {
+    type: string;
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {
+                query: {
+                    type: string;
+                    description: string;
+                };
+                content?: undefined;
+            };
+            required: string[];
+        };
+    };
+})[];

package/dist/tools/openai.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.state = void 0;
+exports.state = [
+    {
+        type: "function",
+        function: {
+            name: "focus",
+            description: "Stores a piece of information in working memory (State/Flux).",
+            parameters: {
+                type: "object",
+                properties: {
+                    content: {
+                        type: "string",
+                        description: "The information to focus on.",
+                    },
+                },
+                required: ["content"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "recall",
+            description: "Recalls relevant memories from State based on a query.",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "The query to search for." },
+                },
+                required: ["query"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "remember",
+            description: "Stores information in long-term memory for future recall.",
+            parameters: {
+                type: "object",
+                properties: {
+                    content: {
+                        type: "string",
+                        description: "The information to remember.",
+                    },
+                },
+                required: ["content"],
+            },
+        },
+    },
+];

package/package.json

@@ -0,0 +1,58 @@
+{
+    "name": "rice-node-sdk",
+    "version": "1.0.0",
+    "description": "SDK for Rice",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        },
+        "./tools/anthropic": {
+            "types": "./dist/tools/anthropic.d.ts",
+            "default": "./dist/tools/anthropic.js"
+        },
+        "./tools/google": {
+            "types": "./dist/tools/google.d.ts",
+            "default": "./dist/tools/google.js"
+        },
+        "./tools/openai": {
+            "types": "./dist/tools/openai.d.ts",
+            "default": "./dist/tools/openai.js"
+        },
+        "./tools/execute": {
+            "types": "./dist/tools/execute.d.ts",
+            "default": "./dist/tools/execute.js"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc && npm run copy-proto",
+        "copy-proto": "mkdir -p dist/state/proto && cp src/state/proto/state.proto dist/state/proto/state.proto",
+        "prepack": "npm run build",
+        "test": "jest"
+    },
+    "keywords": [
+        "rice",
+        "ai"
+    ],
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "@grpc/grpc-js": "^1.10.0",
+        "@grpc/proto-loader": "^0.7.10",
+        "axios": "^1.6.0",
+        "long": "^5.2.3"
+    },
+    "devDependencies": {
+        "@types/jest": "^30.0.0",
+        "@types/node": "^20.0.0",
+        "dotenv": "^17.2.3",
+        "jest": "^30.2.0",
+        "ts-jest": "^29.4.6",
+        "typescript": "^5.3.0"
+    }
+}