aboutsummaryrefslogtreecommitdiff
path: root/packages/tools/src/tools.test.ts
diff options
context:
space:
mode:
Diffstat (limited to 'packages/tools/src/tools.test.ts')
-rw-r--r--packages/tools/src/tools.test.ts232
1 files changed, 118 insertions, 114 deletions
diff --git a/packages/tools/src/tools.test.ts b/packages/tools/src/tools.test.ts
index 5cde729d..bcff0f35 100644
--- a/packages/tools/src/tools.test.ts
+++ b/packages/tools/src/tools.test.ts
@@ -1,70 +1,72 @@
-import { createOpenAI } from "@ai-sdk/openai"
-import { generateText } from "ai"
-import { describe, expect, it } from "vitest"
-import * as aiSdk from "./ai-sdk"
-import * as openAi from "./openai"
-import type { SupermemoryToolsConfig } from "./types"
+import { createOpenAI } from "@ai-sdk/openai";
+import { generateText } from "ai";
+import { describe, expect, it } from "vitest";
+import * as aiSdk from "./ai-sdk";
+import * as openAi from "./openai";
+import type { SupermemoryToolsConfig } from "./types";
-import "dotenv/config"
+import "dotenv/config";
describe("@supermemory/tools", () => {
// Required API keys - tests will fail if not provided
- const testApiKey = process.env.SUPERMEMORY_API_KEY
- const testOpenAIKey = process.env.OPENAI_API_KEY
+ const testApiKey = process.env.SUPERMEMORY_API_KEY;
+ const testOpenAIKey = process.env.OPENAI_API_KEY;
if (!testApiKey) {
throw new Error(
"SUPERMEMORY_API_KEY environment variable is required for tests",
- )
+ );
}
if (!testOpenAIKey) {
- throw new Error("OPENAI_API_KEY environment variable is required for tests")
+ throw new Error(
+ "OPENAI_API_KEY environment variable is required for tests",
+ );
}
// Optional configuration with defaults
- const testBaseUrl = process.env.SUPERMEMORY_BASE_URL ?? undefined
- const testModelName = process.env.MODEL_NAME || "gpt-4o-mini"
+ const testBaseUrl = process.env.SUPERMEMORY_BASE_URL ?? undefined;
+ const testModelName = process.env.MODEL_NAME || "gpt-4o-mini";
describe("aiSdk module", () => {
describe("client initialization", () => {
it("should create tools with default configuration", () => {
- const config: SupermemoryToolsConfig = {}
- const tools = aiSdk.supermemoryTools(testApiKey, config)
+ const config: SupermemoryToolsConfig = {};
+ const tools = aiSdk.supermemoryTools(testApiKey, config);
- expect(tools).toBeDefined()
- expect(tools.searchMemories).toBeDefined()
- expect(tools.addMemory).toBeDefined()
- })
+ expect(tools).toBeDefined();
+ expect(tools.searchMemories).toBeDefined();
+ expect(tools.addMemory).toBeDefined();
+ });
it("should create tools with custom baseUrl", () => {
const config: SupermemoryToolsConfig = {
baseUrl: testBaseUrl,
- }
- const tools = aiSdk.supermemoryTools(testApiKey, config)
+ };
+ const tools = aiSdk.supermemoryTools(testApiKey, config);
- expect(tools).toBeDefined()
- expect(tools.searchMemories).toBeDefined()
- expect(tools.addMemory).toBeDefined()
- })
+ expect(tools).toBeDefined();
+ expect(tools.searchMemories).toBeDefined();
+ expect(tools.addMemory).toBeDefined();
+ });
it("should create individual tools", () => {
const searchTool = aiSdk.searchMemoriesTool(testApiKey, {
projectId: "test-project-123",
- })
+ });
const addTool = aiSdk.addMemoryTool(testApiKey, {
projectId: "test-project-123",
- })
+ });
- expect(searchTool).toBeDefined()
- expect(addTool).toBeDefined()
- })
- })
+ expect(searchTool).toBeDefined();
+ expect(addTool).toBeDefined();
+ });
+ });
describe("AI SDK integration", () => {
it("should work with AI SDK generateText", async () => {
const openai = createOpenAI({
apiKey: testOpenAIKey,
- })
+ });
const result = await generateText({
model: openai(testModelName),
@@ -85,22 +87,22 @@ describe("@supermemory/tools", () => {
baseUrl: testBaseUrl,
}),
},
- })
+ });
- expect(result).toBeDefined()
- expect(result.text).toBeDefined()
- expect(typeof result.text).toBe("string")
- })
+ expect(result).toBeDefined();
+ expect(result.text).toBeDefined();
+ expect(typeof result.text).toBe("string");
+ });
it("should use tools when prompted", async () => {
const openai = createOpenAI({
apiKey: testOpenAIKey,
- })
+ });
const tools = aiSdk.supermemoryTools(testApiKey, {
projectId: "test-tool-usage",
baseUrl: testBaseUrl,
- })
+ });
const result = await generateText({
model: openai(testModelName),
@@ -118,157 +120,159 @@ describe("@supermemory/tools", () => {
tools: {
addMemory: tools.addMemory,
},
- })
+ });
- expect(result).toBeDefined()
- expect(result.text).toBeDefined()
- })
- })
- })
+ expect(result).toBeDefined();
+ expect(result.text).toBeDefined();
+ });
+ });
+ });
describe("openAi module", () => {
describe("function-based tools", () => {
it("should create function-based tools", () => {
const tools = openAi.supermemoryTools(testApiKey, {
projectId: "test-openai-functions",
- })
+ });
- expect(tools).toBeDefined()
- expect(tools.searchMemories).toBeDefined()
- expect(tools.addMemory).toBeDefined()
- })
+ expect(tools).toBeDefined();
+ expect(tools.searchMemories).toBeDefined();
+ expect(tools.addMemory).toBeDefined();
+ });
it("should create individual tool functions", () => {
const searchFunction = openAi.createSearchMemoriesFunction(testApiKey, {
projectId: "test-individual",
- })
+ });
const addFunction = openAi.createAddMemoryFunction(testApiKey, {
projectId: "test-individual",
- })
+ });
- expect(searchFunction).toBeDefined()
- expect(addFunction).toBeDefined()
- expect(typeof searchFunction).toBe("function")
- expect(typeof addFunction).toBe("function")
- })
- })
+ expect(searchFunction).toBeDefined();
+ expect(addFunction).toBeDefined();
+ expect(typeof searchFunction).toBe("function");
+ expect(typeof addFunction).toBe("function");
+ });
+ });
describe("tool definitions", () => {
it("should return proper OpenAI function definitions", () => {
- const definitions = openAi.getToolDefinitions()
+ const definitions = openAi.getToolDefinitions();
- expect(definitions).toBeDefined()
- expect(definitions.length).toBe(2)
+ expect(definitions).toBeDefined();
+ expect(definitions.length).toBe(2);
// Check searchMemories
const searchTool = definitions.find(
(d) => d.function.name === "searchMemories",
- )
- expect(searchTool).toBeDefined()
- expect(searchTool!.type).toBe("function")
+ );
+ expect(searchTool).toBeDefined();
+ expect(searchTool!.type).toBe("function");
expect(searchTool!.function.parameters?.required).toContain(
"informationToGet",
- )
+ );
// Check addMemory
- const addTool = definitions.find((d) => d.function.name === "addMemory")
- expect(addTool).toBeDefined()
- expect(addTool!.type).toBe("function")
- expect(addTool!.function.parameters?.required).toContain("memory")
- })
- })
+ const addTool = definitions.find(
+ (d) => d.function.name === "addMemory",
+ );
+ expect(addTool).toBeDefined();
+ expect(addTool!.type).toBe("function");
+ expect(addTool!.function.parameters?.required).toContain("memory");
+ });
+ });
describe("tool execution", () => {
it("should create tool call executor", () => {
const executor = openAi.createToolCallExecutor(testApiKey, {
containerTags: ["test-executor"],
baseUrl: testBaseUrl,
- })
+ });
- expect(executor).toBeDefined()
- expect(typeof executor).toBe("function")
- })
+ expect(executor).toBeDefined();
+ expect(typeof executor).toBe("function");
+ });
it("should create tool calls executor", () => {
const executor = openAi.createToolCallsExecutor(testApiKey, {
containerTags: ["test-executors"],
baseUrl: testBaseUrl,
- })
+ });
- expect(executor).toBeDefined()
- expect(typeof executor).toBe("function")
- })
- })
+ expect(executor).toBeDefined();
+ expect(typeof executor).toBe("function");
+ });
+ });
describe("individual tool creators", () => {
it("should create individual search tool", () => {
const searchTool = openAi.createSearchMemoriesTool(testApiKey, {
projectId: "test-individual",
- })
+ });
- expect(searchTool).toBeDefined()
- expect(searchTool.definition).toBeDefined()
- expect(searchTool.execute).toBeDefined()
- expect(searchTool.definition.function.name).toBe("searchMemories")
- })
+ expect(searchTool).toBeDefined();
+ expect(searchTool.definition).toBeDefined();
+ expect(searchTool.execute).toBeDefined();
+ expect(searchTool.definition.function.name).toBe("searchMemories");
+ });
it("should create individual add tool", () => {
const addTool = openAi.createAddMemoryTool(testApiKey, {
projectId: "test-individual",
- })
+ });
- expect(addTool).toBeDefined()
- expect(addTool.definition).toBeDefined()
- expect(addTool.execute).toBeDefined()
- expect(addTool.definition.function.name).toBe("addMemory")
- })
- })
+ expect(addTool).toBeDefined();
+ expect(addTool.definition).toBeDefined();
+ expect(addTool.execute).toBeDefined();
+ expect(addTool.definition.function.name).toBe("addMemory");
+ });
+ });
describe("memory operations", () => {
it("should search memories", async () => {
const searchFunction = openAi.createSearchMemoriesFunction(testApiKey, {
projectId: "test-search",
baseUrl: testBaseUrl,
- })
+ });
const result = await searchFunction({
informationToGet: "test preferences",
limit: 5,
- })
+ });
- expect(result).toBeDefined()
- expect(result.success).toBeDefined()
- expect(typeof result.success).toBe("boolean")
+ expect(result).toBeDefined();
+ expect(result.success).toBeDefined();
+ expect(typeof result.success).toBe("boolean");
if (result.success) {
- expect(result.results).toBeDefined()
- expect(result.count).toBeDefined()
- expect(typeof result.count).toBe("number")
+ expect(result.results).toBeDefined();
+ expect(result.count).toBeDefined();
+ expect(typeof result.count).toBe("number");
} else {
- expect(result.error).toBeDefined()
+ expect(result.error).toBeDefined();
}
- })
+ });
it("should add memory", async () => {
const addFunction = openAi.createAddMemoryFunction(testApiKey, {
containerTags: ["test-add-memory"],
baseUrl: testBaseUrl,
- })
+ });
const result = await addFunction({
memory: "User prefers dark roast coffee in the morning - test memory",
- })
+ });
- expect(result).toBeDefined()
- expect(result.success).toBeDefined()
- expect(typeof result.success).toBe("boolean")
+ expect(result).toBeDefined();
+ expect(result.success).toBeDefined();
+ expect(typeof result.success).toBe("boolean");
if (result.success) {
- expect(result.memory).toBeDefined()
+ expect(result.memory).toBeDefined();
} else {
- expect(result.error).toBeDefined()
+ expect(result.error).toBeDefined();
}
- })
- })
- })
-})
+ });
+ });
+ });
+});
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-11 14:24:52 +0000