iotexproject
diff --git a/‎docker-compose.yml‎
Lines changed: 15 additions & 13 deletions b/‎docker-compose.yml‎
Lines changed: 15 additions & 13 deletions
diff --git a/‎package.json‎
Lines changed: 16 additions & 5 deletions b/‎package.json‎
Lines changed: 16 additions & 5 deletions
diff --git a/‎server.ts‎
Lines changed: 26 additions & 2 deletions b/‎server.ts‎
Lines changed: 26 additions & 2 deletions
diff --git a/‎src/__tests__/SentientAI.test.ts‎
Lines changed: 4 additions & 6 deletions b/‎src/__tests__/SentientAI.test.ts‎
Lines changed: 4 additions & 6 deletions
diff --git a/‎src/__tests__/workflow.test.ts‎
Lines changed: 10 additions & 48 deletions b/‎src/__tests__/workflow.test.ts‎
Lines changed: 10 additions & 48 deletions
diff --git a/‎src/llm/llm-service.test.ts‎
Lines changed: 16 additions & 23 deletions b/‎src/llm/llm-service.test.ts‎
Lines changed: 16 additions & 23 deletions
diff --git a/‎src/llm/llm-service.ts‎
Lines changed: 8 additions & 7 deletions b/‎src/llm/llm-service.ts‎
Lines changed: 8 additions & 7 deletions
@@ -4,24 +4,26 @@ services:
   # CONFIG_PATH=configs/instance1.env docker compose up instance1
 
   # Instance with all tools enabled (for testing)
-  test:
-    image: qs:main
-    env_file: configs/.env.test
-    ports:
-      - "8000:8000"
-    restart: always
+  # test:
+  #   image: qs:main
+  #   env_file: configs/.env.test
+  #   ports:
+  #     - "8000:8000"
+  #   restart: always
 
   # Template for production instances (commented out)
   latest:
-    image: qs:latest
+    image: qs:ethdenver
     env_file: configs/.env.latest
     ports:
+      - "33333:3000"
       - "8000:8000"
     restart: always
 
-  # instance2:
-  #   image: qs:main
-  #   env_file: ${CONFIG_PATH}
-  #   ports:
-  #     - "8002:8000"
-  #   restart: always
+  dimo:
+    image: qs:ethdenver
+    env_file: configs/.env.dimo
+    ports:
+      - "33334:3000"
+      - "8001:8000"
+    restart: always
@@ -4,8 +4,8 @@
   "description": "",
   "main": "index.js",
   "scripts": {
-    "start": "bun run server.ts",
-    "dev": "bun run --watch server.ts",
+    "start": "bun run server.ts --server-options=\"{\\\"idleTimeout\\\": 120000}\"",
+    "dev": "bun run --watch server.ts --server-options=\"{\\\"idleTimeout\\\": 120000}\"",
     "test": "vitest run",
     "coverage": "vitest --coverage",
     "format": "bun prettier . --write"
@@ -14,16 +14,27 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.36.2",
+    "@ai-sdk/anthropic": "^1.1.9",
+    "@ai-sdk/deepseek": "^0.1.11",
+    "@ai-sdk/openai": "^1.1.13",
     "@dimo-network/data-sdk": "^1.2.3",
+    "ai": "^4.1.45",
     "axios": "^1.7.9",
     "chalk": "^4.1.2",
     "dotenv": "^16.4.7",
     "ethers": "^6.13.5",
     "hono": "^4.6.16",
-    "openai": "^4.80.1",
+    "logform": "^2.7.0",
     "typescript": "^5.7.2",
-    "winston": "^3.17.0"
+    "winston": "^3.17.0",
+    "zod": "^3.24.2",
+    "@qdrant/js-client-rest": "^1.13.0",
+    "@langchain/qdrant": "^0.1.1",
+    "@upstash/redis": "^1.34.4",
+    "@langchain/community": "^0.3.32",
+    "@langchain/core": "^0.3.40",
+    "@langchain/openai": "^0.4.4",
+    "langchain": "^0.3.19"
   },
   "devDependencies": {
     "@types/axios": "^0.14.4",
 
@@ -29,7 +29,29 @@ app.post("/ask", async (c) => {
     const response = await sentai.execute(content);
     return c.json({ data: response });
   } catch (e) {
-    logger.error(e);
+    console.log("error", e);
+    logger.error("Error in /ask", { error: e });
+    return c.json({ error: "Internal server error." }, 400);
+  }
+});
+
+app.post("/stream", async (c) => {
+  const apiKey = c.req.header("API-KEY");
+  if (!apiKey) {
+    logger.warn("no SENTAI API-KEY provided");
+  }
+
+  try {
+    const formData = await c.req.formData();
+    let content = formData.get("text");
+    const recentMessages = formData.get("recentMessages");
+    if (recentMessages) {
+      content = recentMessages + "\n" + content;
+    }
+    return sentai.stream(content as string);
+  } catch (e) {
+    console.log("error", e);
+    logger.error("Error in /stream", { error: e });
     return c.json({ error: "Internal server error." }, 400);
   }
 });
@@ -57,12 +79,14 @@ app.get("/raw", async (c) => {
     const rawData = await sentai.getRawData(toolName, params);
     return c.json({ data: rawData });
   } catch (e: any) {
-    logger.error(e);
+    console.log("error", e);
+    logger.error("Error in /raw", { error: e });
     return c.json({ error: e.message || "Internal server error" }, 500);
   }
 });
 
 export default {
   port: process.env.PORT || 8000,
   fetch: app.fetch,
+  idleTimeout: 120,
 };
@@ -4,7 +4,7 @@ import { SentientAI } from "../sentientAI";
 
 const currentWeatherOutput = `
 <response>
-["CurrentWeatherAPITool"]
+["get_current_weather"]
 </response>
 `;
 
@@ -19,29 +19,27 @@ describe("SentientAI", () => {
           generate: vi.fn().mockResolvedValue(currentWeatherOutput),
         },
         llm: {
-          generate: vi.fn().mockResolvedValue("<response>+10 C</response>"),
+          generate: vi.fn().mockResolvedValue("+10 C"),
         },
       })),
     }));
     vi.mock("../tools/weather/nubila", () => ({
       CurrentWeatherAPITool: vi.fn().mockImplementation(() => ({
-        name: "CurrentWeatherAPITool",
+        name: "get_current_weather",
         description:
           "Gets the current weather from Nubila API. Input is json with latitude and longitude to retrieve weather data.",
         twitterAccount: "nubilanetwork",
-        execute: vi.fn().mockResolvedValue("+10 C"),
       })),
       ForecastWeatherAPITool: vi.fn().mockImplementation(() => ({
         name: "ForecastWeatherAPITool",
         description:
           "Gets the forecast weather from Nubila API. Input is json with latitude and longitude to retrieve weather data.",
-        execute: vi.fn().mockResolvedValue("+10 C"),
       })),
     }));
     vi.mock("../raw-data-provider", () => ({
       RawDataProvider: vi.fn().mockImplementation(() => ({
         process: vi.fn().mockImplementation((tool, params) => {
-          if (tool.name === "CurrentWeatherAPITool") {
+          if (tool.name === "get_current_weather") {
             return Promise.resolve("+10 C");
           }
           return Promise.reject(new Error(`Unknown tool ${tool.name}`));
 
@@ -2,18 +2,25 @@ import { mockLLMService } from "./mocks";
 import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
 
 import { QueryOrchestrator } from "../workflow";
-import { CurrentWeatherAPITool, ForecastWeatherAPITool } from "../tools/nubila";
+import { CurrentWeatherAPITool } from "../tools/nubila";
 import { LLMService } from "../llm/llm-service";
 import { APITool } from "../tools/tool";
+import { Tool } from "ai";
 
 class TestAPITool extends APITool<any> {
+  schema: { name: string; tool: Tool }[] = [];
+
   async execute(_: string): Promise<string> {
     return "<response>test</response>";
   }
 
   async parseInput(_: string): Promise<any> {
     return "test";
   }
+
+  async getRawData(_: any): Promise<any> {
+    return "test";
+  }
 }
 
 describe("Workflow", () => {
@@ -31,7 +38,7 @@ describe("Workflow", () => {
         generate: vi.fn().mockResolvedValue(queryResponse),
       },
       llm: {
-        generate: vi.fn().mockResolvedValue("<response>+10 C</response>"),
+        generate: vi.fn().mockResolvedValue("+10 C"),
       },
     }));
   };
@@ -82,58 +89,13 @@ describe("Workflow", () => {
         }),
       });
       const res = await workflow.process(
-        "Rephrase the following sentence'Current temperature in SF?'",
+        "Rephrase the following sentence'Current temperature in SF?'"
       );
       expect(res).toBe("What is the weather in SF?");
     });
   });
-  describe("selectTools", () => {
-    it("should return correct single tool", async () => {
-      const workflow = new QueryOrchestrator({
-        tools: [tool],
-        llmService: new LLMService({
-          fastLLMModel: "deepseek-chat",
-          LLMModel: "deepseek-chat",
-        }),
-      });
-      const res = await workflow.selectTools("Current temperature in SF?");
-
-      expect(res.length).toEqual(1);
-      expect(res[0].name).toEqual("Test Tool");
-      expect(res[0].description).toEqual("A test tool");
-      expect(res[0].execute).toBeDefined();
-    });
-    it("should return correct multiple tools", async () => {
-      // @ts-ignore no need to mock private methods
-      vi.mocked(LLMService).mockImplementationOnce(() => ({
-        fastllm: {
-          generate: vi.fn().mockResolvedValue(multipleTools),
-        },
-        llm: {
-          generate: vi.fn().mockResolvedValue("+10 C"),
-        },
-      }));
-      const workflow = new QueryOrchestrator({
-        tools: [new CurrentWeatherAPITool(), new ForecastWeatherAPITool()],
-        llmService: new LLMService({
-          fastLLMModel: "deepseek-chat",
-          LLMModel: "deepseek-chat",
-        }),
-      });
-      const res = await workflow.selectTools("Current temperature in SF?");
-
-      expect(res.length).toEqual(2);
-      expect(res[0].name).toEqual("CurrentWeatherAPITool");
-      expect(res[1].name).toEqual("ForecastWeatherAPITool");
-    });
-  });
 });
 
-const multipleTools = `
-<response>
-["CurrentWeatherAPITool", "ForecastWeatherAPITool"]
-</response>
-`;
 const noTools = `
 <response>
 []
 
@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterAll } from "vitest";
 import { LLMService } from "./llm-service";
-import { AnthropicLLM, OpenAILLM, DummyLLM } from "./llm";
+import { ModelAdapter } from "./llm";
 
 // Mock environment variables
 const originalEnv = process.env;
@@ -21,55 +21,48 @@ describe("LLMService", () => {
         LLMModel: "claude-3-5-sonnet-latest",
       });
 
-      expect(service.fastllm).toBeInstanceOf(AnthropicLLM);
-      expect(service.llm).toBeInstanceOf(AnthropicLLM);
-      expect((service.fastllm as AnthropicLLM).model).toBe(
-        "claude-3-5-haiku-latest",
+      expect((service.fastllm as ModelAdapter).model.modelId).toBe(
+        "claude-3-5-haiku-latest"
       );
-      expect((service.llm as AnthropicLLM).model).toBe(
-        "claude-3-5-sonnet-latest",
+      expect((service.llm as ModelAdapter).model.modelId).toBe(
+        "claude-3-5-sonnet-latest"
       );
     });
 
     it("should initialize with OpenAI models", () => {
-      process.env.OPENAI_API_KEY = "test-key";
       const service = new LLMService({
         fastLLMModel: "gpt-4o",
         LLMModel: "gpt-4o-mini",
       });
 
-      expect(service.fastllm).toBeInstanceOf(OpenAILLM);
-      expect(service.llm).toBeInstanceOf(OpenAILLM);
-      expect((service.fastllm as OpenAILLM).model).toBe("gpt-4o");
-      expect((service.llm as OpenAILLM).model).toBe("gpt-4o-mini");
+      expect((service.fastllm as ModelAdapter).model.modelId).toBe("gpt-4o");
+      expect((service.llm as ModelAdapter).model.modelId).toBe("gpt-4o-mini");
     });
 
     it("should initialize with Deepseek models", () => {
-      process.env.OPENAI_API_KEY = "test-key";
       const service = new LLMService({
         fastLLMModel: "deepseek-chat",
         LLMModel: "deepseek-reasoner",
       });
 
-      expect(service.fastllm).toBeInstanceOf(OpenAILLM);
-      expect(service.llm).toBeInstanceOf(OpenAILLM);
-      expect((service.fastllm as OpenAILLM).model).toBe("deepseek-chat");
-      expect((service.llm as OpenAILLM).model).toBe("deepseek-reasoner");
+      expect((service.fastllm as ModelAdapter).model.modelId).toBe(
+        "deepseek-chat"
+      );
+      expect((service.llm as ModelAdapter).model.modelId).toBe(
+        "deepseek-reasoner"
+      );
     });
 
     it("should mix different providers based on models", () => {
-      process.env.LLM_API_KEY = "test-key";
       const service = new LLMService({
         fastLLMModel: "claude-3-5-haiku-latest",
         LLMModel: "gpt-4o",
       });
 
-      expect(service.fastllm).toBeInstanceOf(AnthropicLLM);
-      expect(service.llm).toBeInstanceOf(OpenAILLM);
-      expect((service.fastllm as AnthropicLLM).model).toBe(
-        "claude-3-5-haiku-latest",
+      expect((service.fastllm as ModelAdapter).model.modelId).toBe(
+        "claude-3-5-haiku-latest"
       );
-      expect((service.llm as OpenAILLM).model).toBe("gpt-4o");
+      expect((service.llm as ModelAdapter).model.modelId).toBe("gpt-4o");
     });
   });
 });
@@ -1,10 +1,11 @@
-import { LLM, AnthropicLLM, OpenAILLM, DummyLLM } from "./llm";
+import { LLM, ModelAdapter, DummyLLM } from "./llm";
 
 const OPENAI_MODELS = new Set(["gpt-4o", "gpt-4o-mini", "o3-mini", "o1-mini"]);
 const DEEPSEEK_MODELS = new Set(["deepseek-chat", "deepseek-reasoner"]);
 const ANTHROPIC_MODELS = new Set([
   "claude-3-5-sonnet-latest",
   "claude-3-5-haiku-latest",
+  "claude-3-7-sonnet-latest",
 ]);
 
 export class LLMService {
@@ -23,19 +24,19 @@ export class LLMService {
 
   providerMap: Record<string, (model?: string) => LLM> = {
     anthropic: (model) =>
-      new AnthropicLLM({
+      new ModelAdapter({
+        provider: "anthropic",
         model: model || "claude-3-5-haiku-latest",
       }),
     deepseek: (model) =>
-      new OpenAILLM({
+      new ModelAdapter({
+        provider: "deepseek",
         model: model || "deepseek-chat",
-        apiKey: process.env.DEEPSEEK_API_KEY || "",
-        baseURL: "https://api.deepseek.com",
       }),
     openai: (model) =>
-      new OpenAILLM({
+      new ModelAdapter({
+        provider: "openai",
         model: model || "gpt-4o-mini",
-        apiKey: process.env.OPENAI_API_KEY || "",
       }),
   };