@memorylayerai/sdk 0.1.0

package/src/resources/memories.ts

@@ -0,0 +1,144 @@
+import { HTTPClient } from '../http-client.js';
+import {
+  Memory,
+  CreateMemoryRequest,
+  UpdateMemoryRequest,
+  ListMemoriesRequest,
+} from '../types.js';
+import { ValidationError } from '../errors.js';
+
+/**
+ * Resource for memory operations
+ */
+export class MemoriesResource {
+  constructor(private httpClient: HTTPClient) {}
+
+  /**
+   * Add a new memory
+   * @param request - Memory creation request
+   * @returns The created memory
+   */
+  async add(request: CreateMemoryRequest): Promise<Memory> {
+    // Validate request
+    if (!request.content || request.content.trim().length === 0) {
+      throw new ValidationError(
+        'Memory content cannot be empty',
+        [{ field: 'content', message: 'Content is required and cannot be empty' }]
+      );
+    }
+    
+    if (!request.projectId || request.projectId.trim().length === 0) {
+      throw new ValidationError(
+        'Project ID is required',
+        [{ field: 'projectId', message: 'Project ID is required' }]
+      );
+    }
+
+    return this.httpClient.request<Memory>({
+      method: 'POST',
+      path: '/v1/memories',
+      body: request,
+    });
+  }
+
+  /**
+   * Get a memory by ID
+   * @param id - Memory ID
+   * @returns The memory
+   */
+  async get(id: string): Promise<Memory> {
+    if (!id || id.trim().length === 0) {
+      throw new ValidationError(
+        'Memory ID is required',
+        [{ field: 'id', message: 'Memory ID is required' }]
+      );
+    }
+
+    return this.httpClient.request<Memory>({
+      method: 'GET',
+      path: `/v1/memories/${id}`,
+    });
+  }
+
+  /**
+   * Update a memory
+   * @param id - Memory ID
+   * @param request - Update request
+   * @returns The updated memory
+   */
+  async update(id: string, request: UpdateMemoryRequest): Promise<Memory> {
+    if (!id || id.trim().length === 0) {
+      throw new ValidationError(
+        'Memory ID is required',
+        [{ field: 'id', message: 'Memory ID is required' }]
+      );
+    }
+
+    if (!request.content && !request.metadata) {
+      throw new ValidationError(
+        'At least one of content or metadata must be provided',
+        [{ field: 'request', message: 'Nothing to update' }]
+      );
+    }
+
+    return this.httpClient.request<Memory>({
+      method: 'PATCH',
+      path: `/v1/memories/${id}`,
+      body: request,
+    });
+  }
+
+  /**
+   * Delete a memory
+   * @param id - Memory ID
+   */
+  async delete(id: string): Promise<void> {
+    if (!id || id.trim().length === 0) {
+      throw new ValidationError(
+        'Memory ID is required',
+        [{ field: 'id', message: 'Memory ID is required' }]
+      );
+    }
+
+    await this.httpClient.request<void>({
+      method: 'DELETE',
+      path: `/v1/memories/${id}`,
+    });
+  }
+
+  /**
+   * List memories
+   * @param request - List request with filters
+   * @returns Array of memories
+   */
+  async list(request: ListMemoriesRequest): Promise<Memory[]> {
+    if (!request.projectId || request.projectId.trim().length === 0) {
+      throw new ValidationError(
+        'Project ID is required',
+        [{ field: 'projectId', message: 'Project ID is required' }]
+      );
+    }
+
+    const query: Record<string, string> = {
+      projectId: request.projectId,
+    };
+
+    if (request.limit !== undefined) {
+      query.limit = request.limit.toString();
+    }
+
+    if (request.offset !== undefined) {
+      query.offset = request.offset.toString();
+    }
+
+    if (request.filter) {
+      query.filter = JSON.stringify(request.filter);
+    }
+
+    return this.httpClient.request<Memory[]>({
+      method: 'GET',
+      path: '/v1/memories',
+      query,
+    });
+  }
+}

package/src/resources/router.ts

@@ -0,0 +1,81 @@
+import { HTTPClient } from '../http-client.js';
+import { RouterRequest, RouterResponse, StreamChunk } from '../types.js';
+import { ValidationError } from '../errors.js';
+
+/**
+ * Resource for router operations
+ */
+export class RouterResource {
+  constructor(private httpClient: HTTPClient) {}
+
+  /**
+   * Complete a router request (non-streaming)
+   * @param request - Router request
+   * @returns Router response
+   */
+  async complete(request: RouterRequest): Promise<RouterResponse> {
+    // Validate request
+    if (!request.messages || request.messages.length === 0) {
+      throw new ValidationError(
+        'Messages array cannot be empty',
+        [{ field: 'messages', message: 'At least one message is required' }]
+      );
+    }
+
+    if (!request.projectId || request.projectId.trim().length === 0) {
+      throw new ValidationError(
+        'Project ID is required',
+        [{ field: 'projectId', message: 'Project ID is required' }]
+      );
+    }
+
+    return this.httpClient.request<RouterResponse>({
+      method: 'POST',
+      path: '/v1/router/complete',
+      body: {
+        ...request,
+        stream: false,
+      },
+    });
+  }
+
+  /**
+   * Stream a router request
+   * @param request - Router request
+   * @returns Async iterable of stream chunks
+   */
+  async *stream(request: RouterRequest): AsyncIterable<StreamChunk> {
+    // Validate request
+    if (!request.messages || request.messages.length === 0) {
+      throw new ValidationError(
+        'Messages array cannot be empty',
+        [{ field: 'messages', message: 'At least one message is required' }]
+      );
+    }
+
+    if (!request.projectId || request.projectId.trim().length === 0) {
+      throw new ValidationError(
+        'Project ID is required',
+        [{ field: 'projectId', message: 'Project ID is required' }]
+      );
+    }
+
+    const stream = this.httpClient.stream({
+      method: 'POST',
+      path: '/v1/router/complete',
+      body: {
+        ...request,
+        stream: true,
+      },
+    });
+
+    try {
+      for await (const chunk of stream) {
+        yield chunk as StreamChunk;
+      }
+    } catch (error) {
+      // Stream errors are already handled by HTTPClient
+      throw error;
+    }
+  }
+}

package/src/resources/search.ts

@@ -0,0 +1,55 @@
+import { HTTPClient } from '../http-client.js';
+import { SearchRequest, SearchResponse } from '../types.js';
+import { ValidationError } from '../errors.js';
+
+/**
+ * Resource for search operations
+ */
+export class SearchResource {
+  constructor(private httpClient: HTTPClient) {}
+
+  /**
+   * Search memories
+   * @param request - Search request
+   * @returns Search results
+   */
+  async search(request: SearchRequest): Promise<SearchResponse> {
+    // Validate request
+    if (!request.query || request.query.trim().length === 0) {
+      throw new ValidationError(
+        'Search query cannot be empty',
+        [{ field: 'query', message: 'Query is required and cannot be empty' }]
+      );
+    }
+
+    if (!request.projectId || request.projectId.trim().length === 0) {
+      throw new ValidationError(
+        'Project ID is required',
+        [{ field: 'projectId', message: 'Project ID is required' }]
+      );
+    }
+
+    const query: Record<string, string> = {
+      q: request.query,
+      projectId: request.projectId,
+    };
+
+    if (request.limit !== undefined) {
+      query.limit = request.limit.toString();
+    }
+
+    if (request.threshold !== undefined) {
+      query.threshold = request.threshold.toString();
+    }
+
+    if (request.filter) {
+      query.filter = JSON.stringify(request.filter);
+    }
+
+    return this.httpClient.request<SearchResponse>({
+      method: 'GET',
+      path: '/v1/search',
+      query,
+    });
+  }
+}

package/src/types.ts

@@ -0,0 +1,225 @@
+/**
+ * Memory object
+ */
+export interface Memory {
+  /** Unique identifier for the memory */
+  id: string;
+  /** Content of the memory */
+  content: string;
+  /** Optional metadata associated with the memory */
+  metadata?: Record<string, any>;
+  /** Project ID this memory belongs to */
+  projectId: string;
+  /** Timestamp when the memory was created */
+  createdAt: string;
+  /** Timestamp when the memory was last updated */
+  updatedAt: string;
+}
+
+/**
+ * Request to create a new memory
+ */
+export interface CreateMemoryRequest {
+  /** Content of the memory */
+  content: string;
+  /** Optional metadata to associate with the memory */
+  metadata?: Record<string, any>;
+  /** Project ID to create the memory in */
+  projectId: string;
+}
+
+/**
+ * Request to update an existing memory
+ */
+export interface UpdateMemoryRequest {
+  /** New content for the memory (optional) */
+  content?: string;
+  /** New metadata for the memory (optional) */
+  metadata?: Record<string, any>;
+}
+
+/**
+ * Request to list memories
+ */
+export interface ListMemoriesRequest {
+  /** Project ID to list memories from */
+  projectId: string;
+  /** Maximum number of memories to return (default: 100) */
+  limit?: number;
+  /** Number of memories to skip (default: 0) */
+  offset?: number;
+  /** Filter criteria for memories */
+  filter?: Record<string, any>;
+}
+
+/**
+ * Search request
+ */
+export interface SearchRequest {
+  /** Search query */
+  query: string;
+  /** Project ID to search in */
+  projectId: string;
+  /** Maximum number of results to return (default: 10) */
+  limit?: number;
+  /** Filter criteria for search */
+  filter?: Record<string, any>;
+  /** Minimum relevance score threshold (0-1) */
+  threshold?: number;
+}
+
+/**
+ * Search result
+ */
+export interface SearchResult {
+  /** The memory that matched the search */
+  memory: Memory;
+  /** Relevance score (0-1) */
+  score: number;
+  /** Highlighted text snippets */
+  highlights?: string[];
+}
+
+/**
+ * Search response
+ */
+export interface SearchResponse {
+  /** Array of search results */
+  results: SearchResult[];
+  /** Total number of results found */
+  total: number;
+}
+
+/**
+ * Request to ingest a file
+ */
+export interface IngestFileRequest {
+  /** File to ingest (Buffer, Blob, or File) */
+  file: Buffer | Blob | File;
+  /** Project ID to ingest into */
+  projectId: string;
+  /** Optional metadata to associate with ingested memories */
+  metadata?: Record<string, any>;
+  /** Chunk size for splitting the file (default: 1000) */
+  chunkSize?: number;
+  /** Overlap between chunks (default: 200) */
+  chunkOverlap?: number;
+}
+
+/**
+ * Request to ingest text
+ */
+export interface IngestTextRequest {
+  /** Text to ingest */
+  text: string;
+  /** Project ID to ingest into */
+  projectId: string;
+  /** Optional metadata to associate with ingested memories */
+  metadata?: Record<string, any>;
+  /** Chunk size for splitting the text (default: 1000) */
+  chunkSize?: number;
+  /** Overlap between chunks (default: 200) */
+  chunkOverlap?: number;
+}
+
+/**
+ * Ingestion response
+ */
+export interface IngestResponse {
+  /** IDs of the created memories */
+  memoryIds: string[];
+  /** Number of chunks created */
+  chunksCreated: number;
+}
+
+/**
+ * Message in a conversation
+ */
+export interface Message {
+  /** Role of the message sender */
+  role: 'user' | 'assistant' | 'system';
+  /** Content of the message */
+  content: string;
+}
+
+/**
+ * Router request
+ */
+export interface RouterRequest {
+  /** Array of messages in the conversation */
+  messages: Message[];
+  /** Project ID for memory context */
+  projectId: string;
+  /** Model to use (optional) */
+  model?: string;
+  /** Temperature for generation (0-2, default: 1) */
+  temperature?: number;
+  /** Maximum tokens to generate */
+  maxTokens?: number;
+  /** Whether to stream the response */
+  stream?: boolean;
+}
+
+/**
+ * Token usage information
+ */
+export interface Usage {
+  /** Number of tokens in the prompt */
+  promptTokens: number;
+  /** Number of tokens in the completion */
+  completionTokens: number;
+  /** Total number of tokens used */
+  totalTokens: number;
+}
+
+/**
+ * Choice in a router response
+ */
+export interface Choice {
+  /** The generated message */
+  message: Message;
+  /** Reason why generation finished */
+  finishReason: string;
+}
+
+/**
+ * Router response
+ */
+export interface RouterResponse {
+  /** Unique identifier for the response */
+  id: string;
+  /** Array of choices (usually one) */
+  choices: Choice[];
+  /** Token usage information */
+  usage: Usage;
+}
+
+/**
+ * Delta in a streaming choice
+ */
+export interface StreamDelta {
+  /** Role of the message (only in first chunk) */
+  role?: string;
+  /** Content chunk */
+  content?: string;
+}
+
+/**
+ * Choice in a streaming response
+ */
+export interface StreamChoice {
+  /** Delta containing the new content */
+  delta: StreamDelta;
+  /** Reason why generation finished (only in last chunk) */
+  finishReason?: string;
+}
+
+/**
+ * Streaming chunk from router
+ */
+export interface StreamChunk {
+  /** Unique identifier for the response */
+  id: string;
+  /** Array of streaming choices */
+  choices: StreamChoice[];
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020"],
+    "moduleResolution": "node",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "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/**']
+    }
+  }
+});