symmetry-cli 1.0.3 → 1.0.5

package/__test__/cli.test.ts

@@ -1,4 +1,4 @@
-import { SymmetryClient } from "../src/client";
+import { SymmetryProvider } from "../src/provider";
 import yaml from "js-yaml";
 
 jest.mock("hyperswarm", () => {
@@ -33,7 +33,7 @@ jest.mock("js-yaml", () => ({
 
 
 describe("Symmetry", () => {
-  let writer: SymmetryClient;
+  let writer: SymmetryProvider;
   const mockConfig = {
     path: "/test/path",
     temperature: 1,
@@ -47,12 +47,13 @@ describe("Symmetry", () => {
     name: "test",
     public: true,
     serverKey: "test-server-key",
+    systemMessage: "test-system-message",
   };
 
   beforeEach(() => {
     jest.clearAllMocks();
     (yaml.load as jest.Mock).mockReturnValue(mockConfig);
-    writer = new SymmetryClient("mock-config.yaml");
+    writer = new SymmetryProvider("mock-config.yaml");
   });
 
   test("init method sets up the writer correctly", async () => {

package/dist/provider.js

@@ -149,7 +149,14 @@ class SymmetryProvider {
     }
     async handleInferenceRequest(data, peer) {
         const emitterKey = data.data.key;
+        const messages = data === null || data === void 0 ? void 0 : data.data.messages;
         const req = this.buildStreamRequest(data === null || data === void 0 ? void 0 : data.data.messages);
+        if (messages.length === 2) {
+            messages.unshift({
+                role: "system",
+                content: this._config.get("systemMessage"),
+            });
+        }
         if (!req)
             return;
         const { requestOptions, requestBody } = req;
@@ -192,10 +199,7 @@ class SymmetryProvider {
             });
             await Promise.resolve(peerPipeline);
             peer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.inferenceEnded, data === null || data === void 0 ? void 0 : data.data.key));
-            if (this._config.get("dataCollectionEnabled") &&
-                data.data.key === constants_1.serverMessageKeys.inference) {
-                this.saveCompletion(completion, peer, data.data.messages);
-            }
+            this.saveCompletion(completion, peer, data.data.messages);
         }
         catch (error) {
             let errorMessage = "An error occurred during inference";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "symmetry-cli",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "",
   "main": "dist/symmetry.js",
   "bin": "dist/symmetry.js",

package/readme.md

@@ -1,63 +1,66 @@
-#  Symmetry
+# Symmetry
 
-In the vast lands of the Internet, where bits and bytes flow like the rivers of old, there arose a tool of great power and purpose. Symmetry the enchanted mirror. With Symmetry, users of the digital realm could offer their computational strength to others, allowing seekers of knowledge to tap into the wisdom of distant machines.
+Use this repository to become an inference provider on the Symmetry network.
+
+Symmetry is a decentralized peer-to-peer network tool that allows users to share computational resources for AI inference. It enables users to connect directly and securely with each other, offering or seeking computational power for various AI tasks.
 
 ## Features
 
-- **Network**: A decentralized network, of interconnected peers.
-- **Configuration**: A scroll of YAML, easily inscribed to bend Symmetry to one's will.
-- **Privacy**: A choice between openness and secrecy.
-- **Data collection**: An option to gather tales of interactions, should the provider wish it so.
+- Decentralized peer-to-peer network
+- YAML-based configuration
+- Privacy options
+- Optional data collection for providers
+- Compatible with various AI inference providers
 
 ## Installation
 
-To call forth Symmetry into your realm, speak these words of power:
+To install Symmetry, use the following commands:
 
-Linux and MacOs
-```
+For Linux and macOS:
+```bash
 curl -fsSL https://raw.githubusercontent.com/twinnydotdev/symmetry/master/install.sh | sh
 ```
 
-Windows
-```
+For Windows:
+```powershell
 iwr -useb https://raw.githubusercontent.com/twinnydotdev/symmetry/master/install.ps1 | iex
 ```
 
 ## Usage
 
-To awaken Symmetry, utter this command:
+To start Symmetry, run:
 
-```
+```bash
 symmetry-cli
 ```
 
-Symmetry will seek its tome of knowledge in the halls of `~/.config/symmetry/provider.yaml`. Should you wish to direct it to another scroll, speak thus:
+By default, Symmetry looks for its configuration file at `~/.config/symmetry/provider.yaml`. To use a different configuration file, use:
 
-```
-symmetry -c /path/to/your/sacred/provider.yaml
+```bash
+symmetry-cli -c /path/to/your/provider.yaml
 ```
 
 ## Configuration
 
-Inscribe your `provider.yaml` with these mystical runes:
+Here's an example `provider.yaml` configuration:
 
 ```yaml
-apiHostname: localhost # The dwelling of your local oracle
-apiKey: # The secret word to commune with your oracle
-apiPath: /v1/chat/completions # The path to wisdom
-apiPort: 11434 # The gate through which knowledge flows
-apiProtocol: http # The method of communion
-apiProvider: ollama # The lineage of your oracle
-dataCollectionEnabled: true # Whether to gather lore
-maxConnections: 10 # The limit of simultaneous seekers
-modelName: llama3:8b # The true name of your oracle
-name: # Your title in this realm
-path: /home/richard/.config/symmetry/default # The dwelling for data
-public: true # Whether your services are open to all
-serverKey: 4b4a9cc325d134dee6679e9407420023531fd7e96c563f6c5d00fd5549b77435 # The key of the central tower
+apiHostname: localhost  # The hostname of the API server.
+apiKey:  # The API key for authentication.
+apiPath: /v1/chat/completions  # The endpoint path for chat completions.
+apiPort: 11434  # The port number on which the API server is listening.
+apiProtocol: http  # The protocol used to communicate with the API server.
+apiProvider: ollama  # The name of the API provider.
+dataCollectionEnabled: false  # Whether to enable data collection.
+maxConnections: 10  # The maximum number of connections.
+modelName: llama3.1:latest  # The name and version of the AI model to use.
+name: twinnydotdev  # Your chosen name as a provider on the Symmetry network.
+path: /home/twinnydotdev/.config/symmetry/data  # The local path where Symmetry will store its configuration and data files.
+public: true  # Whether this provider is publicly accessible on the Symmetry network.
+serverKey: 4b4a9cc325d134dee6679e9407420023531fd7e96c563f6c5d00fd5549b77435  # The unique key for connecting to the Symmetry server.
 ```
 
-Adjust these runes to align with your own preferences.
+Adjust these settings according to your preferences and setup.
 
 ## Architecture
 
@@ -88,80 +91,46 @@ graph TB
     
     C1 <--> |"4. Inference<br/>Request/Response"| P2
     C2 <--> |"4. Inference<br/>Request/Response"| P3
-
-    style S fill:#ff9900,stroke:#333,stroke-width:4px
-    style P1 fill:#00ccff,stroke:#333,stroke-width:2px
-    style P2 fill:#00ccff,stroke:#333,stroke-width:2px
-    style P3 fill:#00ccff,stroke:#333,stroke-width:2px
-    style C1 fill:#333,stroke:#fff,stroke-width:2px
-    style C2 fill:#333,stroke:#fff,stroke-width:2px
 ```
 
-### Server, Providers and Clients:
-- **Central Server**: Symmetry Server, a beacon of order in the chaotic digital winds.
-- **Providers**: Inference Providers, keepers of knowledge and computational might.
-- **Client**: Clients, adventurers in search of answers from the oracles of data.
-
-### Connection:
-
-1. The Providers approach the Central Tower, proving their worth and declaring their specialties.
-2. Seekers call out to the Tower, their questions echoing in the digital void.
-3. The Tower, in its wisdom, guides each Seeker to a suitable Provider.
-4. Seeker and Provider join in a dance of query and response, their connection direct and true.
-
-### Communication:
-
-- All messages between Seekers and Providers are cloaked in unbreakable encryption, safe from prying eyes.
-- The Providers may choose to remember the tales told to them, a choice they must declare openly.
-- Seekers are granted the wisdom to choose their Providers based on these declarations of memory.
+## Development
 
-### Features:
+To set up Symmetry for development:
 
-- **Adaptability**: As changeable as the seasons, ready for new knowledge and new seekers.
-- **Swiftness**: Direct connections ensure that wisdom flows like the rapids of a mountain stream.
-- **Guardianship**: Only the worthy may enter this circle of trust.
-- **Balance**: The Tower ensures no single Provider bears too heavy a burden.
-- **Growth**: New Providers may join the circle, expanding the realm of possibility.
-
-Thus does Symmetry weave its web of connections, bringing together the seekers and keepers of digital wisdom in a grand tapestry of knowledge and computation.
-
-## Forging of Symmetry
-
-For those who wish to shape Symmetry with their own hands:
-
-1. Summon the essence:
-   ```
+1. Clone the repository:
+   ```bash
    git clone https://github.com/twinnydotdev/symmetry.git
    cd symmetry
    ```
 
-2. Gather the necessary elements:
-   ```
+2. Install dependencies:
+   ```bash
    npm install
    ```
 
-3. Forge the tool:
-   ```
+3. Build the project:
+   ```bash
    npm run build
    ```
 
-4. Awaken:
-   ```
-   npm start
+4. Start the development server:
+   ```bash
+   npm run dev
    ```
 
-## Call for Heroes
+## Contributing
+
+Contributions are welcome! Please submit your pull requests to the [GitHub repository](https://github.com/twinnydotdev/symmetry/pulls).
 
-Brave souls willing to improve upon this grand design are most welcome. Present your [scrolls of change](https://github.com/twinnydotdev/symmetry/pulls) for consideration.
+## License
 
-## Covenant
+This project is licensed under the [MIT License](https://github.com/twinnydotdev/symmetry/blob/master/LICENCE).
 
-This work is protected under the [Oath of MIT](https://github.com/twinnydotdev/symmetry/blob/main/LICENSE), a sacred bond between creator and user.
+## Support
 
-## Council of Elders
+If you encounter any issues or have questions, please [open an issue](https://github.com/twinnydotdev/symmetry/issues) on GitHub.
 
-Should you face trials or seek guidance, bring your [queries](https://github.com/twinnydotdev/symmetry/issues) before the Council on GitHub.
+## Acknowledgments
 
-## A Nod to the Ancients
+We thank [Hyperswarm](https://github.com/holepunchto/hyperswarm) for providing the underlying peer-to-peer networking capabilities.
 
-We pay homage to [Hyperswarm](https://github.com/holepunchto/hyperswarm), the tool that makes our connections possible.

package/src/provider.ts

@@ -13,10 +13,8 @@ import {
   safeParseStreamResponse,
 } from "./utils";
 import { logger } from "./logger";
-import { Peer, ProviderMessage, InferenceRequest } from "./types";
-import {
-  serverMessageKeys,
-} from "./constants";
+import { Peer, ProviderMessage, InferenceRequest, Message } from "./types";
+import { serverMessageKeys } from "./constants";
 
 export class SymmetryProvider {
   private _challenge: Buffer | null = null;
@@ -65,7 +63,7 @@ export class SymmetryProvider {
         chalk.white(`🔑 Server key: ${this._config.get("serverKey")}`)
       );
       logger.info(chalk.white("🔗 Joining server, please wait."));
-      await this.joinServer();
+      this.testProviderCall();
     }
 
     process.on("SIGINT", async () => {
@@ -80,6 +78,66 @@ export class SymmetryProvider {
     });
   }
 
+  private async testProviderCall(): Promise<void> {
+    logger.info(chalk.white(`👋 Saying hello to your provider...`));
+    const testMessages: Message[] = [
+      { role: "user", content: "Hello, this is a test message." },
+    ];
+    const req = this.buildStreamRequest(testMessages);
+
+    if (!req) {
+      logger.error(chalk.red("❌ Failed to build test request"));
+      throw new Error("Failed to build test request");
+    }
+
+    const { requestOptions, requestBody } = req;
+    const { protocol, hostname, port, path, method, headers } = requestOptions;
+    const url = `${protocol}://${hostname}:${port}${path}`;
+
+    logger.info(chalk.white(`🚀 Sending test request to ${url}`));
+
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: JSON.stringify(requestBody),
+      });
+
+      if (!response.ok) {
+        logger.error(
+          chalk.red(`❌ Server responded with status code: ${response.status}`)
+        );
+        throw new Error(
+          `Server responded with status code: ${response.status}`
+        );
+      }
+
+      if (!response.body) {
+        logger.error(
+          chalk.red("❌ Failed to get a ReadableStream from the response")
+        );
+        throw new Error("Failed to get a ReadableStream from the response");
+      }
+
+      logger.info(chalk.white(`📡 Got response, checking stream...`));
+
+      const reader = response.body.getReader();
+      const { done } = await reader.read();
+      if (done) {
+        logger.error(chalk.red("❌ Stream ended without data"));
+        throw new Error("Stream ended without data");
+      }
+
+      logger.info(chalk.green(`✅ Test inference call successful!`));
+    } catch (error) {
+      logger.error(chalk.red(`❌ Error during test inference call: ${error}`));
+      throw error;
+    }
+
+    logger.info(chalk.white(`🔗 Proceeding to join server...`));
+    await this.joinServer();
+  }
+
   async joinServer(): Promise<void> {
     const serverSwarm = new Hyperswarm();
     const serverKey = Buffer.from(this._config.get("serverKey"));
@@ -192,13 +250,24 @@ export class SymmetryProvider {
     });
   }
 
+  private getMessagesWithSystem(messages: Message[]): Message[] {
+    const systemMessage = this._config.get("systemMessage");
+    if (messages.length === 2 && systemMessage) {
+      messages.unshift({
+        role: "system",
+        content: systemMessage,
+      });
+    }
+    return messages;
+  }
+
   private async handleInferenceRequest(
     data: ProviderMessage<InferenceRequest>,
     peer: Peer
   ): Promise<void> {
     const emitterKey = data.data.key;
-
-    const req = this.buildStreamRequest(data?.data.messages);
+    const messages = this.getMessagesWithSystem(data?.data.messages);
+    const req = this.buildStreamRequest(messages);
 
     if (!req) return;
 
@@ -277,7 +346,7 @@ export class SymmetryProvider {
   private async saveCompletion(
     completion: string,
     peer: Peer,
-    messages: { role: string; content: string }[]
+    messages: Message[]
   ) {
     fs.writeFile(
       `${this._config.get("path")}/${peer.publicKey.toString("hex")}-${
@@ -296,7 +365,7 @@ export class SymmetryProvider {
     );
   }
 
-  private buildStreamRequest(messages: { role: string; content: string }[]) {
+  private buildStreamRequest(messages: Message[]) {
     const requestOptions = {
       hostname: this._config.get("apiHostname"),
       port: Number(this._config.get("apiPort")),

package/src/types.ts

@@ -18,6 +18,7 @@ export interface ProviderConfig {
   port: number;
   public: boolean;
   serverKey: string;
+  systemMessage: string;
 }
 
 export interface ProviderMessage<T = unknown> {
@@ -27,7 +28,7 @@ export interface ProviderMessage<T = unknown> {
 
 export interface InferenceRequest {
   key: string;
-  messages: { role: string; content: string }[];
+  messages: Message[];
 }
 
 interface ReadableState {