@memorylayerai/vercel-ai 0.2.0

package/src/provider.ts

@@ -0,0 +1,154 @@
+/**
+ * Vercel AI SDK provider adapter for MemoryLayer
+ */
+
+import type { MemoryLayerClient } from '@memorylayer/sdk';
+
+/**
+ * Configuration for the MemoryLayer provider
+ */
+export interface MemoryLayerProviderConfig {
+  /** MemoryLayer client instance */
+  client: MemoryLayerClient;
+  /** Project ID for memory context */
+  projectId: string;
+  /** Default model to use */
+  defaultModel?: string;
+}
+
+/**
+ * Create a Vercel AI SDK provider for MemoryLayer
+ * 
+ * @param config - Provider configuration
+ * @returns Vercel AI SDK compatible provider
+ * 
+ * @example
+ * ```typescript
+ * import { createMemoryLayerProvider } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ * 
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ * 
+ * const provider = createMemoryLayerProvider({
+ *   client,
+ *   projectId: 'proj_abc123',
+ * });
+ * 
+ * const { text } = await generateText({
+ *   model: provider,
+ *   prompt: 'What are my preferences?',
+ * });
+ * ```
+ */
+export function createMemoryLayerProvider(config: MemoryLayerProviderConfig): any {
+  return {
+    specificationVersion: 'v1',
+    provider: 'memorylayer',
+    modelId: config.defaultModel || 'default',
+
+    /**
+     * Generate a completion (non-streaming)
+     */
+    async doGenerate(options: any) {
+      // Convert Vercel AI SDK format to MemoryLayer format
+      const messages = options.prompt.map((msg: any) => ({
+        role: msg.role,
+        content: msg.content,
+      }));
+
+      const response = await config.client.router.complete({
+        messages,
+        projectId: config.projectId,
+        model: options.model || config.defaultModel,
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+      });
+
+      // Convert MemoryLayer format to Vercel AI SDK format
+      return {
+        text: response.choices[0].message.content,
+        finishReason: response.choices[0].finishReason,
+        usage: {
+          promptTokens: response.usage.promptTokens,
+          completionTokens: response.usage.completionTokens,
+        },
+        rawCall: {
+          rawPrompt: messages,
+          rawSettings: {
+            model: options.model || config.defaultModel,
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
+          },
+        },
+      };
+    },
+
+    /**
+     * Generate a streaming completion
+     */
+    async doStream(options: any) {
+      // Convert Vercel AI SDK format to MemoryLayer format
+      const messages = options.prompt.map((msg: any) => ({
+        role: msg.role,
+        content: msg.content,
+      }));
+
+      const stream = config.client.router.stream({
+        messages,
+        projectId: config.projectId,
+        model: options.model || config.defaultModel,
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+        stream: true,
+      });
+
+      // Convert MemoryLayer stream to Vercel AI SDK stream format
+      const convertedStream = convertToVercelStream(stream);
+
+      return {
+        stream: convertedStream,
+        rawCall: {
+          rawPrompt: messages,
+          rawSettings: {
+            model: options.model || config.defaultModel,
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
+          },
+        },
+      };
+    },
+  };
+}
+
+/**
+ * Convert MemoryLayer stream to Vercel AI SDK stream format
+ */
+async function* convertToVercelStream(stream: AsyncIterable<any>): AsyncIterable<any> {
+  try {
+    for await (const chunk of stream) {
+      // Convert MemoryLayer chunk format to Vercel AI SDK format
+      yield {
+        type: 'text-delta',
+        textDelta: chunk.choices[0]?.delta?.content || '',
+      };
+
+      // Check for finish reason
+      if (chunk.choices[0]?.finishReason) {
+        yield {
+          type: 'finish',
+          finishReason: chunk.choices[0].finishReason,
+        };
+      }
+    }
+  } catch (error) {
+    // Convert MemoryLayer errors to Vercel AI SDK error format
+    throw {
+      name: 'AI_APICallError',
+      message: error instanceof Error ? error.message : 'Unknown error',
+      cause: error,
+    };
+  }
+}

package/src/tools.ts

@@ -0,0 +1,133 @@
+/**
+ * Vercel AI SDK tool helpers for MemoryLayer
+ */
+
+import type { MemoryLayerClient } from '@memorylayer/sdk';
+import { z } from 'zod';
+
+/**
+ * Configuration for memory tools
+ */
+export interface MemoryToolConfig {
+  /** MemoryLayer client instance */
+  client: MemoryLayerClient;
+  /** Project ID for memory operations */
+  projectId: string;
+}
+
+/**
+ * Create a Vercel AI SDK tool for adding memories
+ * 
+ * @param config - Tool configuration
+ * @returns Vercel AI SDK tool definition
+ * 
+ * @example
+ * ```typescript
+ * import { memoryTool } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ * 
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ * 
+ * const { text } = await generateText({
+ *   model: someModel,
+ *   prompt: 'Remember that I prefer dark mode',
+ *   tools: {
+ *     addMemory: memoryTool({ client, projectId: 'proj_abc123' }),
+ *   },
+ * });
+ * ```
+ */
+export function memoryTool(config: MemoryToolConfig) {
+  return {
+    description: 'Add a memory to the MemoryLayer system for long-term storage',
+    parameters: z.object({
+      content: z.string().describe('The content to remember'),
+      metadata: z.record(z.any()).optional().describe('Optional metadata to associate with the memory'),
+    }),
+    execute: async ({ content, metadata }: { content: string; metadata?: Record<string, any> }) => {
+      try {
+        const memory = await config.client.memories.add({
+          content,
+          metadata,
+          projectId: config.projectId,
+        });
+
+        return {
+          success: true,
+          memoryId: memory.id,
+          message: `Memory stored successfully with ID: ${memory.id}`,
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : 'Unknown error',
+        };
+      }
+    },
+  };
+}
+
+/**
+ * Create a Vercel AI SDK tool for searching memories
+ * 
+ * @param config - Tool configuration
+ * @returns Vercel AI SDK tool definition
+ * 
+ * @example
+ * ```typescript
+ * import { searchTool } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ * 
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ * 
+ * const { text } = await generateText({
+ *   model: someModel,
+ *   prompt: 'What are my preferences?',
+ *   tools: {
+ *     searchMemory: searchTool({ client, projectId: 'proj_abc123' }),
+ *   },
+ * });
+ * ```
+ */
+export function searchTool(config: MemoryToolConfig) {
+  return {
+    description: 'Search memories in the MemoryLayer system to retrieve relevant information',
+    parameters: z.object({
+      query: z.string().describe('The search query to find relevant memories'),
+      limit: z.number().optional().describe('Maximum number of results to return (default: 10)'),
+      threshold: z.number().optional().describe('Minimum relevance score threshold (0-1)'),
+    }),
+    execute: async ({ query, limit, threshold }: { query: string; limit?: number; threshold?: number }) => {
+      try {
+        const response = await config.client.search.search({
+          query,
+          projectId: config.projectId,
+          limit,
+          threshold,
+        });
+
+        return {
+          success: true,
+          results: response.results.map((r: any) => ({
+            content: r.memory.content,
+            score: r.score,
+            metadata: r.memory.metadata,
+            id: r.memory.id,
+          })),
+          total: response.total,
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : 'Unknown error',
+        };
+      }
+    },
+  };
+}

package/tests/graph.test.ts

@@ -0,0 +1,316 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { graphTool, nodeDetailsTool, nodeEdgesTool, createGraphTools } from '../src/graph.js';
+import type { MemoryLayerClient, GraphData, NodeDetails, GetNodeEdgesResponse } from '@memorylayer/sdk';
+
+/**
+ * Graph Tools Tests for Vercel AI SDK
+ * 
+ * These tests verify the graph tools work correctly with the Vercel AI SDK.
+ * 
+ * Requirements: 6.1, 6.2, 6.3
+ */
+
+describe('Graph Tools', () => {
+  let mockClient: MemoryLayerClient;
+
+  beforeEach(() => {
+    mockClient = {
+      graph: {
+        getGraph: vi.fn(),
+        getNodeDetails: vi.fn(),
+        getNodeEdges: vi.fn(),
+        getAllGraphPages: vi.fn(),
+      },
+    } as unknown as MemoryLayerClient;
+  });
+
+  describe('graphTool', () => {
+    it('should create a valid tool with correct schema', () => {
+      const tool = graphTool({ client: mockClient, spaceId: 'test-space' });
+
+      expect(tool).toBeDefined();
+      expect(tool.description).toContain('memory graph');
+      expect(tool.parameters).toBeDefined();
+      expect(tool.execute).toBeDefined();
+    });
+
+    it('should execute and return graph data', async () => {
+      const mockGraphData: GraphData = {
+        nodes: [
+          {
+            id: 'node-1',
+            type: 'memory',
+            label: 'Test Memory',
+            data: {
+              status: 'latest',
+              createdAt: '2026-01-20T00:00:00Z',
+              content: 'Test content',
+            },
+          },
+        ],
+        edges: [
+          {
+            id: 'edge-1',
+            source: 'node-1',
+            target: 'node-2',
+            type: 'extends',
+            label: 'extends',
+            data: {
+              strength: 0.9,
+            },
+          },
+        ],
+        metadata: {
+          totalNodes: 1,
+          memoryCount: 1,
+          documentCount: 0,
+          entityCount: 0,
+          totalEdges: 1,
+          relationshipCount: 1,
+          similarityCount: 0,
+        },
+        pagination: {
+          hasMore: false,
+        },
+      };
+
+      vi.mocked(mockClient.graph.getGraph).mockResolvedValue(mockGraphData);
+
+      const tool = graphTool({ client: mockClient, spaceId: 'test-space' });
+      const result = await tool.execute({ limit: 10 });
+
+      expect(mockClient.graph.getGraph).toHaveBeenCalledWith({
+        spaceId: 'test-space',
+        limit: 10,
+        nodeTypes: undefined,
+        relationshipTypes: undefined,
+        startDate: undefined,
+        endDate: undefined,
+      });
+
+      expect(result.nodes).toHaveLength(1);
+      expect(result.nodes[0].id).toBe('node-1');
+      expect(result.edges).toHaveLength(1);
+      expect(result.edges[0].id).toBe('edge-1');
+      expect(result.metadata).toBeDefined();
+    });
+
+    it('should pass filters to getGraph', async () => {
+      const mockGraphData: GraphData = {
+        nodes: [],
+        edges: [],
+        metadata: {
+          totalNodes: 0,
+          memoryCount: 0,
+          documentCount: 0,
+          entityCount: 0,
+          totalEdges: 0,
+          relationshipCount: 0,
+          similarityCount: 0,
+        },
+        pagination: {
+          hasMore: false,
+        },
+      };
+
+      vi.mocked(mockClient.graph.getGraph).mockResolvedValue(mockGraphData);
+
+      const tool = graphTool({ client: mockClient, spaceId: 'test-space' });
+      await tool.execute({
+        limit: 50,
+        nodeTypes: ['memory'],
+        relationshipTypes: ['extends'],
+        startDate: '2026-01-01T00:00:00Z',
+        endDate: '2026-01-31T23:59:59Z',
+      });
+
+      expect(mockClient.graph.getGraph).toHaveBeenCalledWith({
+        spaceId: 'test-space',
+        limit: 50,
+        nodeTypes: ['memory'],
+        relationshipTypes: ['extends'],
+        startDate: '2026-01-01T00:00:00Z',
+        endDate: '2026-01-31T23:59:59Z',
+      });
+    });
+  });
+
+  describe('nodeDetailsTool', () => {
+    it('should create a valid tool with correct schema', () => {
+      const tool = nodeDetailsTool({ client: mockClient, spaceId: 'test-space' });
+
+      expect(tool).toBeDefined();
+      expect(tool.description).toContain('node');
+      expect(tool.parameters).toBeDefined();
+      expect(tool.execute).toBeDefined();
+    });
+
+    it('should execute and return node details', async () => {
+      const mockDetails: NodeDetails = {
+        node: {
+          id: 'node-1',
+          type: 'memory',
+          label: 'Test Memory',
+          data: {
+            status: 'latest',
+            createdAt: '2026-01-20T00:00:00Z',
+            content: 'Full content here',
+          },
+        },
+        edges: [
+          {
+            id: 'edge-1',
+            source: 'node-1',
+            target: 'node-2',
+            type: 'extends',
+            label: 'extends',
+            data: {
+              strength: 0.9,
+            },
+          },
+        ],
+        connectedNodes: [
+          {
+            id: 'node-2',
+            type: 'memory',
+            label: 'Connected Memory',
+            data: {
+              status: 'latest',
+              createdAt: '2026-01-20T00:00:00Z',
+            },
+          },
+        ],
+      };
+
+      vi.mocked(mockClient.graph.getNodeDetails).mockResolvedValue(mockDetails);
+
+      const tool = nodeDetailsTool({ client: mockClient, spaceId: 'test-space' });
+      const result = await tool.execute({ nodeId: 'node-1' });
+
+      expect(mockClient.graph.getNodeDetails).toHaveBeenCalledWith({
+        nodeId: 'node-1',
+      });
+
+      expect(result.node.id).toBe('node-1');
+      expect(result.node.content).toBe('Full content here');
+      expect(result.edges).toHaveLength(1);
+      expect(result.connectedNodes).toHaveLength(1);
+    });
+  });
+
+  describe('nodeEdgesTool', () => {
+    it('should create a valid tool with correct schema', () => {
+      const tool = nodeEdgesTool({ client: mockClient, spaceId: 'test-space' });
+
+      expect(tool).toBeDefined();
+      expect(tool.description).toContain('edges');
+      expect(tool.parameters).toBeDefined();
+      expect(tool.execute).toBeDefined();
+    });
+
+    it('should execute and return node edges', async () => {
+      const mockEdges: GetNodeEdgesResponse = {
+        edges: [
+          {
+            id: 'edge-1',
+            source: 'node-1',
+            target: 'node-2',
+            type: 'extends',
+            label: 'extends',
+            data: {
+              strength: 0.9,
+            },
+          },
+        ],
+        connectedNodes: [
+          {
+            id: 'node-2',
+            type: 'memory',
+            label: 'Connected Memory',
+            data: {
+              status: 'latest',
+              createdAt: '2026-01-20T00:00:00Z',
+            },
+          },
+        ],
+      };
+
+      vi.mocked(mockClient.graph.getNodeEdges).mockResolvedValue(mockEdges);
+
+      const tool = nodeEdgesTool({ client: mockClient, spaceId: 'test-space' });
+      const result = await tool.execute({ nodeId: 'node-1' });
+
+      expect(mockClient.graph.getNodeEdges).toHaveBeenCalledWith({
+        nodeId: 'node-1',
+        edgeTypes: undefined,
+      });
+
+      expect(result.edges).toHaveLength(1);
+      expect(result.connectedNodes).toHaveLength(1);
+    });
+
+    it('should pass edge type filters', async () => {
+      const mockEdges: GetNodeEdgesResponse = {
+        edges: [],
+        connectedNodes: [],
+      };
+
+      vi.mocked(mockClient.graph.getNodeEdges).mockResolvedValue(mockEdges);
+
+      const tool = nodeEdgesTool({ client: mockClient, spaceId: 'test-space' });
+      await tool.execute({
+        nodeId: 'node-1',
+        edgeTypes: ['extends', 'updates'],
+      });
+
+      expect(mockClient.graph.getNodeEdges).toHaveBeenCalledWith({
+        nodeId: 'node-1',
+        edgeTypes: ['extends', 'updates'],
+      });
+    });
+  });
+
+  describe('createGraphTools', () => {
+    it('should create all graph tools', () => {
+      const tools = createGraphTools({ client: mockClient, spaceId: 'test-space' });
+
+      expect(tools).toBeDefined();
+      expect(tools.getGraph).toBeDefined();
+      expect(tools.getNodeDetails).toBeDefined();
+      expect(tools.getNodeEdges).toBeDefined();
+    });
+
+    it('should create tools that share the same config', async () => {
+      const mockGraphData: GraphData = {
+        nodes: [],
+        edges: [],
+        metadata: {
+          totalNodes: 0,
+          memoryCount: 0,
+          documentCount: 0,
+          entityCount: 0,
+          totalEdges: 0,
+          relationshipCount: 0,
+          similarityCount: 0,
+        },
+        pagination: {
+          hasMore: false,
+        },
+      };
+
+      vi.mocked(mockClient.graph.getGraph).mockResolvedValue(mockGraphData);
+
+      const tools = createGraphTools({ client: mockClient, spaceId: 'test-space-123' });
+      await tools.getGraph.execute({});
+
+      expect(mockClient.graph.getGraph).toHaveBeenCalledWith({
+        spaceId: 'test-space-123',
+        limit: undefined,
+        nodeTypes: undefined,
+        relationshipTypes: undefined,
+        startDate: undefined,
+        endDate: undefined,
+      });
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020"],
+    "moduleResolution": "node",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "paths": {
+      "@memorylayer/sdk": ["../node-sdk/src/index.ts"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: ['**/*.test.ts', '**/dist/**', '**/node_modules/**']
+    }
+  }
+});