notdiamond 0.0.2 → 0.0.4

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+## [0.0.2](https://github.com/Not-Diamond/notdiamond-node/pull/4) (2024-05-22)
+
+### Bug Fixes
+
+- Cleaned up readme [4c33bd8be65850ef4c5ca34aa9d18c60ee44ead5](https://github.com/Not-Diamond/notdiamond-node/pull/4/commits/4c33bd8be65850ef4c5ca34aa9d18c60ee44ead5)
+
+## [0.0.1](https://github.com/Not-Diamond/notdiamond-node/tree/32bccf352544414e1486c170b90cf00f75041190) (2024-05-22)
+
+### Initial release
+
+- Code setup

package/README.md

@@ -13,7 +13,7 @@ npm install notdiamond
 You can import in Deno via:
 
 ```ts
-import NotDiamond from 'https://deno.land/x/notdiamond@v1.0.0/mod.ts';
+import { NotDiamond } from 'https://deno.land/x/notdiamond@v1.0.0/mod.ts';
 ```
 
 ## Usage
@@ -21,24 +21,32 @@ import NotDiamond from 'https://deno.land/x/notdiamond@v1.0.0/mod.ts';
 The full API of this library can be found in `api.md` file along with many code examples. The code below shows how to get started using the chat completions API.
 
 ```ts
-import NotDiamond from 'notdiamond';
+import { NotDiamond } from '../src/notdiamond';
 
-const notdiamond = new NotDiamond();
+const notDiamond = new NotDiamond({
+  apiKey: process.env.NOTDIAMOND_API_KEY,
+});
 
 async function main() {
-  const { providers, session_id } = await notdiamond.hashModelSelect({
+  const result = await notDiamond.hashModelSelect({
     messages: [{ content: 'What is 12x12?', role: 'user' }],
     llmProviders: [
-      { provider: 'openai', model: 'gpt-4o' },
+      { provider: 'openai', model: 'gpt-4' },
+      { provider: 'openai', model: 'gpt-3.5-turbo' },
       { provider: 'anthropic', model: 'claude-3-opus-20240229' },
-      { provider: 'google', model: 'gemini-1.5-pro' },
+      { provider: 'anthropic', model: 'claude-3-sonnet-20240229' },
     ],
     preferenceWeights: { quality: 0.7, cost: 0.1, latency: 0.2 },
+    maxModelDepth: 2,
   });
-
-  console.log(providers);
-  console.log(session_id);
+  if ('detail' in result) {
+    // There was an error
+    console.error(result.detail);
+    return;
+  }
+  const { providers, session_id } = result;
+  console.log({ providers, session_id });
 }
 
-main();
+void main();
 ```

package/dist/index.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+const dotenv = require('dotenv');
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
+const dotenv__namespace = /*#__PURE__*/_interopNamespaceCompat(dotenv);
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+dotenv__namespace.config();
+const BASE_URL = "https://not-diamond-server.onrender.com";
+const HASH_MODEL_SELECT_URL = `${BASE_URL}/v2/optimizer/hashModelSelect`;
+const FEEDBACK_URL = `${BASE_URL}/v1/report/metrics/feedback`;
+const LATENCY_URL = `${BASE_URL}/v1/report/metrics/latency`;
+class NotDiamond {
+  constructor(options = {}) {
+    __publicField(this, "apiKey");
+    this.apiKey = options.apiKey || process.env.NOTDIAMOND_API_KEY || "";
+  }
+  getAuthHeader() {
+    const authHeader = `Bearer ${this.apiKey}`;
+    return authHeader;
+  }
+  async postRequest(url, body) {
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: this.getAuthHeader(),
+          accept: "application/json",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const errorData = await response.json();
+        return { detail: errorData.detail };
+      }
+      const responseData = await response.json();
+      return responseData;
+    } catch (error) {
+      return { detail: "An unexpected error occurred." };
+    }
+  }
+  async hashModelSelect(options) {
+    return this.postRequest(
+      HASH_MODEL_SELECT_URL,
+      {
+        messages: options.messages,
+        llm_providers: options.llmProviders,
+        ...options.preferenceWeights && {
+          preference_weights: options.preferenceWeights
+        },
+        ...options.maxModelDepth && {
+          max_model_depth: options.maxModelDepth
+        },
+        ...options.tools && { tools: options.tools }
+      }
+    );
+  }
+  async feedback(options) {
+    return this.postRequest(FEEDBACK_URL, {
+      session_id: options.sessionId,
+      feedback: options.feedback,
+      provider: options.provider
+    });
+  }
+  async latency(options) {
+    return this.postRequest(LATENCY_URL, {
+      session_id: options.sessionId,
+      feedback: options.feedback,
+      provider: options.provider
+    });
+  }
+}
+
+exports.NotDiamond = NotDiamond;

package/dist/index.d.cts

@@ -0,0 +1,66 @@
+interface NotDiamondOptions {
+    apiKey?: string;
+}
+interface Provider {
+    provider: string;
+    model: string;
+}
+interface NotDiamondErrorResponse {
+    detail: string;
+}
+interface Tool {
+    type: string;
+    functions: Record<string, string>;
+}
+interface Message {
+    content: string;
+    role: 'user' | 'assistant' | 'system';
+}
+interface HashModelSelectOptions {
+    messages: Message[];
+    llmProviders: Provider[];
+    tools?: Tool[];
+    maxModelDepth?: number;
+    preferenceWeights?: {
+        quality: number;
+        cost: number;
+        latency?: number;
+        preference_id?: string;
+    };
+}
+interface HashModelSelectSuccessResponse {
+    providers: Provider[];
+    session_id: string;
+}
+interface Feedback {
+    accuracy: number;
+}
+interface FeedbackOptions {
+    sessionId: string;
+    feedback: Feedback;
+    provider: Provider;
+}
+interface FeedbackSuccessResponse {
+    session_id: string;
+    feedback: Feedback;
+}
+interface LatencyOptions {
+    sessionId: string;
+    feedback: Feedback;
+    provider: Provider;
+}
+interface LatencySuccessResponse {
+    session_id: string;
+    tokens_per_second: number;
+}
+declare class NotDiamond {
+    private apiKey;
+    constructor(options?: NotDiamondOptions);
+    private getAuthHeader;
+    private postRequest;
+    hashModelSelect(options: HashModelSelectOptions): Promise<HashModelSelectSuccessResponse | NotDiamondErrorResponse>;
+    feedback(options: FeedbackOptions): Promise<FeedbackSuccessResponse | NotDiamondErrorResponse>;
+    latency(options: LatencyOptions): Promise<LatencySuccessResponse | NotDiamondErrorResponse>;
+}
+
+export { type Feedback, type FeedbackOptions, type FeedbackSuccessResponse, type HashModelSelectOptions, type HashModelSelectSuccessResponse, type LatencyOptions, type LatencySuccessResponse, type Message, NotDiamond, type NotDiamondErrorResponse, type NotDiamondOptions, type Provider, type Tool };

package/dist/index.d.mts

@@ -0,0 +1,66 @@
+interface NotDiamondOptions {
+    apiKey?: string;
+}
+interface Provider {
+    provider: string;
+    model: string;
+}
+interface NotDiamondErrorResponse {
+    detail: string;
+}
+interface Tool {
+    type: string;
+    functions: Record<string, string>;
+}
+interface Message {
+    content: string;
+    role: 'user' | 'assistant' | 'system';
+}
+interface HashModelSelectOptions {
+    messages: Message[];
+    llmProviders: Provider[];
+    tools?: Tool[];
+    maxModelDepth?: number;
+    preferenceWeights?: {
+        quality: number;
+        cost: number;
+        latency?: number;
+        preference_id?: string;
+    };
+}
+interface HashModelSelectSuccessResponse {
+    providers: Provider[];
+    session_id: string;
+}
+interface Feedback {
+    accuracy: number;
+}
+interface FeedbackOptions {
+    sessionId: string;
+    feedback: Feedback;
+    provider: Provider;
+}
+interface FeedbackSuccessResponse {
+    session_id: string;
+    feedback: Feedback;
+}
+interface LatencyOptions {
+    sessionId: string;
+    feedback: Feedback;
+    provider: Provider;
+}
+interface LatencySuccessResponse {
+    session_id: string;
+    tokens_per_second: number;
+}
+declare class NotDiamond {
+    private apiKey;
+    constructor(options?: NotDiamondOptions);
+    private getAuthHeader;
+    private postRequest;
+    hashModelSelect(options: HashModelSelectOptions): Promise<HashModelSelectSuccessResponse | NotDiamondErrorResponse>;
+    feedback(options: FeedbackOptions): Promise<FeedbackSuccessResponse | NotDiamondErrorResponse>;
+    latency(options: LatencyOptions): Promise<LatencySuccessResponse | NotDiamondErrorResponse>;
+}
+
+export { type Feedback, type FeedbackOptions, type FeedbackSuccessResponse, type HashModelSelectOptions, type HashModelSelectSuccessResponse, type LatencyOptions, type LatencySuccessResponse, type Message, NotDiamond, type NotDiamondErrorResponse, type NotDiamondOptions, type Provider, type Tool };

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+interface NotDiamondOptions {
+    apiKey?: string;
+}
+interface Provider {
+    provider: string;
+    model: string;
+}
+interface NotDiamondErrorResponse {
+    detail: string;
+}
+interface Tool {
+    type: string;
+    functions: Record<string, string>;
+}
+interface Message {
+    content: string;
+    role: 'user' | 'assistant' | 'system';
+}
+interface HashModelSelectOptions {
+    messages: Message[];
+    llmProviders: Provider[];
+    tools?: Tool[];
+    maxModelDepth?: number;
+    preferenceWeights?: {
+        quality: number;
+        cost: number;
+        latency?: number;
+        preference_id?: string;
+    };
+}
+interface HashModelSelectSuccessResponse {
+    providers: Provider[];
+    session_id: string;
+}
+interface Feedback {
+    accuracy: number;
+}
+interface FeedbackOptions {
+    sessionId: string;
+    feedback: Feedback;
+    provider: Provider;
+}
+interface FeedbackSuccessResponse {
+    session_id: string;
+    feedback: Feedback;
+}
+interface LatencyOptions {
+    sessionId: string;
+    feedback: Feedback;
+    provider: Provider;
+}
+interface LatencySuccessResponse {
+    session_id: string;
+    tokens_per_second: number;
+}
+declare class NotDiamond {
+    private apiKey;
+    constructor(options?: NotDiamondOptions);
+    private getAuthHeader;
+    private postRequest;
+    hashModelSelect(options: HashModelSelectOptions): Promise<HashModelSelectSuccessResponse | NotDiamondErrorResponse>;
+    feedback(options: FeedbackOptions): Promise<FeedbackSuccessResponse | NotDiamondErrorResponse>;
+    latency(options: LatencyOptions): Promise<LatencySuccessResponse | NotDiamondErrorResponse>;
+}
+
+export { type Feedback, type FeedbackOptions, type FeedbackSuccessResponse, type HashModelSelectOptions, type HashModelSelectSuccessResponse, type LatencyOptions, type LatencySuccessResponse, type Message, NotDiamond, type NotDiamondErrorResponse, type NotDiamondOptions, type Provider, type Tool };

package/dist/index.mjs

@@ -0,0 +1,76 @@
+import * as dotenv from 'dotenv';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+dotenv.config();
+const BASE_URL = "https://not-diamond-server.onrender.com";
+const HASH_MODEL_SELECT_URL = `${BASE_URL}/v2/optimizer/hashModelSelect`;
+const FEEDBACK_URL = `${BASE_URL}/v1/report/metrics/feedback`;
+const LATENCY_URL = `${BASE_URL}/v1/report/metrics/latency`;
+class NotDiamond {
+  constructor(options = {}) {
+    __publicField(this, "apiKey");
+    this.apiKey = options.apiKey || process.env.NOTDIAMOND_API_KEY || "";
+  }
+  getAuthHeader() {
+    const authHeader = `Bearer ${this.apiKey}`;
+    return authHeader;
+  }
+  async postRequest(url, body) {
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: this.getAuthHeader(),
+          accept: "application/json",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const errorData = await response.json();
+        return { detail: errorData.detail };
+      }
+      const responseData = await response.json();
+      return responseData;
+    } catch (error) {
+      return { detail: "An unexpected error occurred." };
+    }
+  }
+  async hashModelSelect(options) {
+    return this.postRequest(
+      HASH_MODEL_SELECT_URL,
+      {
+        messages: options.messages,
+        llm_providers: options.llmProviders,
+        ...options.preferenceWeights && {
+          preference_weights: options.preferenceWeights
+        },
+        ...options.maxModelDepth && {
+          max_model_depth: options.maxModelDepth
+        },
+        ...options.tools && { tools: options.tools }
+      }
+    );
+  }
+  async feedback(options) {
+    return this.postRequest(FEEDBACK_URL, {
+      session_id: options.sessionId,
+      feedback: options.feedback,
+      provider: options.provider
+    });
+  }
+  async latency(options) {
+    return this.postRequest(LATENCY_URL, {
+      session_id: options.sessionId,
+      feedback: options.feedback,
+      provider: options.provider
+    });
+  }
+}
+
+export { NotDiamond };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "notdiamond",
   "type": "module",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "author": "not-diamond",
   "license": "MIT",
   "description": "TS/JS client for the NotDiamond API",
@@ -25,10 +25,15 @@
     "dist"
   ],
   "keywords": [
-    "boilerplate",
+    "ai",
+    "not-diamond",
     "typescript",
-    "release",
-    "swc"
+    "openai",
+    "chatgpt",
+    "anthropic",
+    "claude",
+    "gemini",
+    "model router"
   ],
   "scripts": {
     "prepare": "husky install",
@@ -86,5 +91,9 @@
   },
   "resolutions": {
     "wrap-ansi": "7.0.0"
+  },
+  "engines": {
+    "node": ">=20",
+    "npm": ">=8"
   }
 }