@lumi0/sdk 0.0.3 → 0.0.5

package/README.md

@@ -1,146 +1,753 @@
 # Lumi0 TypeScript SDK
 
-The official TypeScript SDK for storing, retrieving, and compressing persistent
-AI memory with Lumi0.
+The official TypeScript SDK for [Lumi0](https://lumi0.com), an AI infrastructure platform for persistent memory, context compression, and document ingestion.
+
+Lumi0 gives AI applications long-term memory: store information about users, retrieve relevant context with semantic search, manage memory versions, batch-write memories, forget stored information, upload documents from URLs, and compress large contexts before sending them to an LLM.
+
+## Features
+
+* Persistent AI memory
+* Semantic memory search
+* Memory versioning
+* Batch memory storage
+* Memory deduplication
+* Context compression
+* Fixed and adaptive compression modes
+* URL-based document ingestion
+* Automatic document type detection
+* TypeScript-first API
+* Bun and Node.js compatible
+* Configurable API URL and request timeout
 
 ## Installation
 
+### Bun
+
 ```bash
 bun add @lumi0/sdk
 ```
 
+### npm
+
 ```bash
 npm install @lumi0/sdk
 ```
 
-## Quick start
+## Requirements
 
-Create a client with a Lumi0 API key:
+* Node.js 18+ or Bun
+* A Lumi0 API key
+
+Set your API key as an environment variable:
+
+```bash
+LUMI0_API_KEY=your_api_key
+```
+
+Never expose your Lumi0 API key in browser-side code. Keep it on your server or in a trusted backend environment.
+
+## Quick Start
+
+Create a Lumi0 client:
 
 ```ts
 import { Lumi0 } from "@lumi0/sdk";
 
 const client = new Lumi0({
-	apiKey: process.env.LUMI0_API_KEY!,
+    apiKey: process.env.LUMI0_API_KEY!,
 });
 ```
 
-Store a memory, then search for relevant context:
+### Store a memory
+
+Store information associated with an identifier:
 
 ```ts
 await client.store({
-	id: "user_123",
-	content: "The user prefers concise TypeScript examples.",
+    id: "user_123",
+    content: "The user prefers concise TypeScript examples.",
 });
+```
+
+### Search memories
 
+Retrieve memories that are semantically relevant to a query:
+
+```ts
 const memories = await client.search({
-	id: "user_123",
-	query: "What coding examples does the user prefer?",
-	limit: 5,
+    id: "user_123",
+    query: "What coding examples does the user prefer?",
+    limit: 5,
 });
+
+console.log(memories);
+```
+
+### Upload a document
+
+Upload a document directly from a URL:
+
+```ts
+const upload = await client.files({
+    url: "https://example.com/document.pdf",
+    id: "tenant_123",
+});
+```
+
+The `id` identifies the tenant or external entity the uploaded document belongs to. It can be either a Lumi0 tenant ID or your own external ID.
+
+A common AI application flow looks like:
+
+```text
+User
+  ↓
+Your AI Application
+  ↓
+Lumi0
+  ├── Memory
+  ├── File Ingestion
+  └── Context Compression
+  ↓
+Relevant Context
+  ↓
+LLM
+  ↓
+Response
 ```
 
-## API
+## API Reference
 
-### `store`
+### `store()`
 
-Stores one memory for an identifier.
+Stores a single memory for an identifier.
 
 ```ts
 await client.store({
-	id: "user_123",
-	content: "The user uses Bun and TypeScript.",
-	dedupeThreshold: 0.9,
+    id: "user_123",
+    content: "The user uses Bun and TypeScript.",
 });
 ```
 
-### `batch`
+You can optionally configure deduplication:
 
-Stores multiple memories in one request.
+```ts
+await client.store({
+    id: "user_123",
+    content: "The user uses Bun and TypeScript.",
+    dedupeThreshold: 0.9,
+});
+```
+
+`dedupeThreshold` controls how similar an existing memory can be before Lumi0 considers the new memory a duplicate.
+
+### `batch()`
+
+Stores multiple memories in a single request.
 
 ```ts
 await client.batch([
-	{
-		id: "user_123",
-		content: "The user works with Hono.",
-	},
-	{
-		id: "user_123",
-		content: "The user prefers practical implementation details.",
-	},
+    {
+        id: "user_123",
+        content: "The user works with Hono.",
+    },
+    {
+        id: "user_123",
+        content: "The user prefers practical implementation details.",
+    },
+    {
+        id: "user_123",
+        content: "The user uses Bun for backend services.",
+    },
 ]);
 ```
 
-### `search`
+Batching is useful when your application needs to save multiple pieces of context at once.
 
-Searches memories semantically.
+For example, after a conversation:
+
+```ts
+await client.batch([
+    {
+        id: "user_123",
+        content: "The user is building an AI application.",
+    },
+    {
+        id: "user_123",
+        content: "The user prefers TypeScript.",
+    },
+    {
+        id: "user_123",
+        content: "The user uses Bun for backend development.",
+    },
+]);
+```
+
+### `search()`
+
+Searches stored memories semantically.
 
 ```ts
 const memories = await client.search({
-	id: "user_123",
-	query: "Which backend framework does the user use?",
-	limit: 10,
-	minSimilarity: 0.7,
-	memoryType: "semantic",
+    id: "user_123",
+    query: "Which backend framework does the user use?",
+    limit: 10,
+    minSimilarity: 0.7,
+    memoryType: "semantic",
 });
 ```
 
-### `get`
+You can use `limit` to control the maximum number of memories returned.
+
+`minSimilarity` can be used to filter out results below a similarity threshold.
 
-Retrieves a memory by identifier. Pass `version` to retrieve a specific version.
+You can also specify a memory type:
+
+```ts
+const memories = await client.search({
+    id: "user_123",
+    query: "What does the user know about this project?",
+    memoryType: "semantic",
+});
+```
+
+### `get()`
+
+Retrieves a memory by its identifier.
 
 ```ts
 const memory = await client.get({
-	id: "memory_123",
-	version: 2,
+    id: "memory_123",
 });
 ```
 
-### `forget`
+To retrieve a specific version:
 
-Deletes a memory for a user.
+```ts
+const memory = await client.get({
+    id: "memory_123",
+    version: 2,
+});
+```
+
+This is useful when your application needs to inspect a particular historical version of a memory.
+
+### `forget()`
+
+Deletes a stored memory.
 
 ```ts
 await client.forget({
-	id: "memory_123"
+    id: "memory_123",
 });
 ```
 
-### `compress`
+### `files()`
+
+Uploads and ingests a document from a URL.
+
+```ts
+const upload = await client.files({
+    url: "https://example.com/document.pdf",
+    id: "tenant_123",
+});
+```
 
-Reduces context while retaining information relevant to a query.
+The `id` can be either a Lumi0 tenant ID or an external ID from your application.
+
+Lumi0 determines the document type from the URL and supports the following file extensions:
+
+| Extension | MIME type                                                                   |
+| --------- | --------------------------------------------------------------------------- |
+| `.csv`    | `text/csv`                                                                  |
+| `.docx`   | `application/vnd.openxmlformats-officedocument.wordprocessingml.document`   |
+| `.eml`    | `message/rfc822`                                                            |
+| `.htm`    | `text/html`                                                                 |
+| `.html`   | `text/html`                                                                 |
+| `.json`   | `application/json`                                                          |
+| `.jsonl`  | `application/x-ndjson`                                                      |
+| `.md`     | `text/markdown`                                                             |
+| `.mdx`    | `text/markdown`                                                             |
+| `.mbox`   | `application/mbox`                                                          |
+| `.pdf`    | `application/pdf`                                                           |
+| `.pptx`   | `application/vnd.openxmlformats-officedocument.presentationml.presentation` |
+| `.tsv`    | `text/tab-separated-values`                                                 |
+| `.txt`    | `text/plain`                                                                |
+| `.xls`    | `application/vnd.ms-excel`                                                  |
+| `.xlsx`   | `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`         |
+| `.xml`    | `application/xml`                                                           |
+| `.yaml`   | `application/yaml`                                                          |
+| `.yml`    | `application/yaml`                                                          |
+
+Example:
+
+```ts
+const upload = await client.files({
+    url: "https://example.com/company-handbook.pdf",
+    id: "customer_123",
+});
+
+console.log(upload);
+```
+
+This allows applications to ingest documents without first downloading and uploading the file themselves.
+
+### `compress()`
+
+Compresses context while attempting to retain information that is relevant to a query.
+
+This is useful before sending large context windows to an LLM.
 
 ```ts
 const result = await client.compress({
-	content: JSON.stringify(memories),
-	query: "What is the user's preferred backend stack?",
-	mode: "adaptive",
-	budgetRatio: 0.5,
+    content: JSON.stringify(memories),
+    query: "What is the user's preferred backend stack?",
+    mode: "adaptive",
+    budgetRatio: 0.5,
 });
 
 console.log(result.data.compressedText);
 console.log(`${result.data.tokensSaved} tokens saved`);
 ```
 
-Use `"fixed"` mode with `budgetRatio` to target a specific retained-context
-ratio. Use `"adaptive"` mode to let Lumi0 determine the appropriate amount of
-context to retain for the query.
+The returned data can be used as the context for your LLM request:
+
+```ts
+const result = await client.compress({
+    content: JSON.stringify(memories),
+    query: "What is the user's preferred backend stack?",
+    mode: "adaptive",
+    budgetRatio: 0.5,
+});
+
+const context = result.data.compressedText;
+
+// Pass `context` to your LLM.
+```
+
+#### Compression modes
+
+Lumi0 supports two compression modes.
+
+**Adaptive**
+
+```ts
+await client.compress({
+    content,
+    query,
+    mode: "adaptive",
+    budgetRatio: 0.5,
+});
+```
+
+Adaptive compression allows Lumi0 to determine how much context should be retained based on the query and content.
+
+**Fixed**
+
+```ts
+await client.compress({
+    content,
+    query,
+    mode: "fixed",
+    budgetRatio: 0.5,
+});
+```
+
+Fixed compression uses `budgetRatio` to target a specific retained-context ratio.
+
+For example, a `budgetRatio` of `0.5` targets approximately half of the original context budget.
+
+## Building an AI Memory Loop
+
+A typical application can combine `store()` and `search()`:
+
+```ts
+import { Lumi0 } from "@lumi0/sdk";
+
+const client = new Lumi0({
+    apiKey: process.env.LUMI0_API_KEY!,
+});
+
+// Save information learned from the conversation.
+await client.store({
+    id: "user_123",
+    content: "The user prefers concise answers.",
+});
+
+// Retrieve relevant memories before generating a response.
+const memories = await client.search({
+    id: "user_123",
+    query: "How should I respond to this user?",
+    limit: 5,
+});
+```
+
+You can then inject the retrieved memories into your LLM context.
+
+## File Ingestion + Memory
+
+Lumi0 can combine external documents with persistent memory.
+
+For example, an application can ingest a document for a tenant and later use the resulting knowledge alongside stored memories:
+
+```ts
+const upload = await client.files({
+    url: "https://example.com/product-documentation.pdf",
+    id: "tenant_123",
+});
+
+await client.store({
+    id: "tenant_123",
+    content: "The customer is building an AI support application.",
+});
+```
+
+This provides a simple pipeline for applications that need both user-specific memory and external document knowledge.
+
+## Memory + Compression
+
+For applications with large memory collections, you can combine semantic retrieval with compression:
+
+```ts
+const memories = await client.search({
+    id: "user_123",
+    query: "What does the user prefer when writing code?",
+    limit: 20,
+    minSimilarity: 0.7,
+});
+
+const compressed = await client.compress({
+    content: JSON.stringify(memories),
+    query: "What does the user prefer when writing code?",
+    mode: "adaptive",
+    budgetRatio: 0.5,
+});
+
+const context = compressed.data.compressedText;
+
+console.log(context);
+```
+
+This creates a pipeline:
+
+```text
+Stored Memories
+      ↓
+Semantic Search
+      ↓
+Relevant Memories
+      ↓
+Context Compression
+      ↓
+Compressed Context
+      ↓
+LLM
+```
 
 ## Configuration
 
+The client accepts configuration options:
+
+```ts
+const client = new Lumi0({
+    apiKey: process.env.LUMI0_API_KEY!,
+    baseUrl: "https://api.lumi0.com/api/v1",
+    timeout: 30_000,
+});
+```
+
+### `apiKey`
+
+Your Lumi0 API key.
+
+```ts
+apiKey: process.env.LUMI0_API_KEY!
+```
+
+### `baseUrl`
+
+The Lumi0 API endpoint.
+
+Default:
+
+```text
+https://api.lumi0.com/api/v1
+```
+
+You can override it:
+
+```ts
+const client = new Lumi0({
+    apiKey: process.env.LUMI0_API_KEY!,
+    baseUrl: "https://api.lumi0.com/api/v1",
+});
+```
+
+This can be useful when working with a different API environment.
+
+### `timeout`
+
+Maximum time, in milliseconds, that the SDK waits for an HTTP request.
+
+Default:
+
+```ts
+30_000
+```
+
+Example:
+
 ```ts
 const client = new Lumi0({
-	apiKey: process.env.LUMI0_API_KEY!,
-	baseUrl: "https://api.lumi0.com/api/v1",
-	timeout: 30_000,
+    apiKey: process.env.LUMI0_API_KEY!,
+    timeout: 60_000,
 });
 ```
 
-`baseUrl` defaults to `https://api.lumi0.com/api/v1` and `timeout` defaults to
-30 seconds.
+## Environment Variables
+
+A typical `.env` file:
+
+```env
+LUMI0_API_KEY=your_api_key
+```
+
+Then:
+
+```ts
+import { Lumi0 } from "@lumi0/sdk";
+
+const client = new Lumi0({
+    apiKey: process.env.LUMI0_API_KEY!,
+});
+```
+
+Do not commit your `.env` file or API keys to source control.
+
+## Error Handling
+
+SDK requests reject with an `Error` when Lumi0 returns a non-success HTTP status.
+
+Use `try/catch` around SDK operations:
+
+```ts
+try {
+    const memories = await client.search({
+        id: "user_123",
+        query: "What does the user prefer?",
+        limit: 5,
+    });
+
+    console.log(memories);
+} catch (error) {
+    console.error("Lumi0 request failed:", error);
+}
+```
+
+The error message includes the HTTP status and the API-provided error message when available.
+
+For production applications, handle failures explicitly rather than assuming every operation succeeds.
+
+## Server-Side Usage
+
+The Lumi0 API key should be kept private.
+
+Recommended:
+
+```ts
+// Server-side code
+const client = new Lumi0({
+    apiKey: process.env.LUMI0_API_KEY!,
+});
+```
+
+Avoid putting your API key directly into client-side applications:
+
+```ts
+// Don't expose your secret API key in browser code.
+const client = new Lumi0({
+    apiKey: "your-secret-api-key",
+});
+```
+
+For a Next.js application, use Lumi0 from server-side code such as API routes, Route Handlers, Server Actions, or your backend.
+
+## Example: User Memory
+
+A simple chat application can save user preferences:
+
+```ts
+await client.store({
+    id: "user_123",
+    content: "The user prefers concise responses.",
+});
+
+await client.store({
+    id: "user_123",
+    content: "The user prefers TypeScript examples.",
+});
+
+await client.store({
+    id: "user_123",
+    content: "The user uses Bun.",
+});
+```
+
+Later, retrieve the relevant information:
+
+```ts
+const memories = await client.search({
+    id: "user_123",
+    query: "What should I know about this user's coding preferences?",
+    limit: 10,
+});
+```
+
+## Example: Conversation Memory
+
+You can store useful information extracted from a conversation:
+
+```ts
+await client.batch([
+    {
+        id: "user_123",
+        content: "The user is building a SaaS application.",
+    },
+    {
+        id: "user_123",
+        content: "The user uses TypeScript for backend development.",
+    },
+    {
+        id: "user_123",
+        content: "The user prefers concise technical explanations.",
+    },
+]);
+```
+
+Then retrieve only the information relevant to a new request:
+
+```ts
+const memories = await client.search({
+    id: "user_123",
+    query: "What technical preferences should I consider?",
+    limit: 5,
+});
+```
+
+## TypeScript
+
+The SDK is designed for TypeScript applications and provides typed method interfaces.
+
+```ts
+import { Lumi0 } from "@lumi0/sdk";
+
+const client = new Lumi0({
+    apiKey: process.env.LUMI0_API_KEY!,
+});
+
+const result = await client.search({
+    id: "user_123",
+    query: "What does the user prefer?",
+    limit: 5,
+});
+```
+
+Your editor can provide autocomplete and type checking for Lumi0 client methods and their options.
+
+## Runtime Support
+
+The SDK is designed to work with modern JavaScript runtimes, including:
+
+* Bun
+* Node.js
+
+Bun installation:
+
+```bash
+bun add @lumi0/sdk
+```
+
+npm installation:
+
+```bash
+npm install @lumi0/sdk
+```
+
+## API Summary
+
+| Method       | Purpose                                 |
+| ------------ | --------------------------------------- |
+| `store()`    | Store one memory                        |
+| `batch()`    | Store multiple memories                 |
+| `search()`   | Semantically search memories            |
+| `get()`      | Retrieve a memory or specific version   |
+| `forget()`   | Delete a memory                         |
+| `files()`    | Upload and ingest a document from a URL |
+| `compress()` | Compress context relevant to a query    |
+
+## Complete Example
+
+```ts
+import { Lumi0 } from "@lumi0/sdk";
+
+const client = new Lumi0({
+    apiKey: process.env.LUMI0_API_KEY!,
+});
+
+async function main() {
+    // Upload a document.
+    const upload = await client.files({
+        url: "https://example.com/document.pdf",
+        id: "tenant_123",
+    });
+
+    console.log(upload);
+
+    // Store memories.
+    await client.batch([
+        {
+            id: "user_123",
+            content: "The user prefers concise TypeScript examples.",
+        },
+        {
+            id: "user_123",
+            content: "The user uses Bun for backend development.",
+        },
+        {
+            id: "user_123",
+            content: "The user works with Hono.",
+        },
+    ]);
+
+    // Search relevant memories.
+    const memories = await client.search({
+        id: "user_123",
+        query: "What backend technologies does the user use?",
+        limit: 10,
+        minSimilarity: 0.7,
+        memoryType: "semantic",
+    });
+
+    // Compress retrieved context.
+    const compressed = await client.compress({
+        content: JSON.stringify(memories),
+        query: "What backend technologies does the user use?",
+        mode: "adaptive",
+        budgetRatio: 0.5,
+    });
+
+    console.log(compressed.data.compressedText);
+    console.log(`${compressed.data.tokensSaved} tokens saved`);
+}
+
+main().catch(console.error);
+```
+
+## Links
+
+* Website: https://lumi0.com
+* API: https://api.lumi0.com
+* npm: https://www.npmjs.com/package/@lumi0/sdk
 
-## Errors
+## License
 
-SDK requests reject with an `Error` when Lumi0 returns a non-success status.
-The error message includes the HTTP status and the API-provided error message
-when available.
+MIT

package/dist/index.d.mts

@@ -1,14 +1,43 @@
 //#region src/types.d.ts
+interface HttpClientOptions {
+  baseUrl: string;
+  apiKey: string;
+  timeout?: number;
+  headers?: globalThis.HeadersInit;
+}
+interface ErrorResponse {
+  message?: string;
+  error?: string;
+}
 type Lumi0Options = {
   apiKey: string;
   baseUrl?: string;
   timeout?: number;
 };
+type PostBody = Record<string, unknown>;
+interface IPostBody {
+  userId: string;
+  collectionId: string;
+}
 interface StoreMemoryInput {
   content: string;
   dedupeThreshold?: number;
   id: string;
 }
+interface BuildContextInput {
+  id: string;
+  query: string;
+  limit?: number;
+  minSimilarity?: number;
+}
+interface UploadFileInput {
+  id: string;
+  url: string;
+}
+interface MemoryRollbackInput {
+  memoryId: string;
+  version: number;
+}
 interface SearchMemoryInput {
   query: string;
   limit?: number;
@@ -26,7 +55,24 @@ interface CompressMemoryInput {
   budgetRatio?: number;
   mode: "fixed" | "adaptive";
 }
-interface CompressMemoryResult {
+interface MemoryVersion {
+  id: string;
+  memoryId: string;
+  version: number;
+  action: "created" | "updated" | "deleted";
+  content: string;
+  metadata: {
+    tags: string[];
+    summary: string;
+    category: string;
+    externalId: string;
+    importance: number;
+    memoryType: "semantic" | "episodic" | "procedural";
+  };
+  createdBy: string;
+  createdAt: string;
+}
+interface Compress {
   compressedText: string;
   originalTokens: number;
   keptTokens: number;
@@ -37,24 +83,62 @@ interface CompressMemoryResult {
   policyName: string;
   keptLineRatio: number;
 }
-interface CompressMemoryApiResponse {
-  success: boolean;
-  data: CompressMemoryResult;
-}
 interface ForgetMemoryInput {
   id: string;
 }
+interface Context {
+  data: string;
+}
+interface Search {
+  id: string;
+  collectionId: string;
+  externalId: string;
+  content: string;
+  memoryType: string;
+  importance: number;
+  category: string;
+  summary: string;
+  tags: string[];
+  version: number;
+  createdAt: Date;
+  updatedAt: Date;
+  similarity: number;
+}
+//#endregion
+//#region src/http.d.ts
+declare class HttpClient {
+  private readonly options;
+  constructor(options: HttpClientOptions);
+  request<T>(path: string, init?: RequestInit): Promise<T>;
+  get<T>(path: string): Promise<T>;
+  post<T>(path: string, body?: unknown): Promise<T>;
+  put<T>(path: string, body?: unknown): Promise<T>;
+  patch<T>(path: string, body?: unknown): Promise<T>;
+  delete<T>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<T>;
+  private parseError;
+}
+//#endregion
+//#region src/memory.d.ts
+declare class MemoryApi {
+  private readonly http;
+  constructor(http: HttpClient);
+  history(id: string): Promise<MemoryVersion[]>;
+  rollback(input: MemoryRollbackInput): Promise<unknown>;
+}
 //#endregion
 //#region src/client.d.ts
 declare class Lumi0 {
   private readonly http;
+  readonly mem: MemoryApi;
   constructor(option: Lumi0Options);
   store(input: StoreMemoryInput): Promise<unknown>;
-  search(input: SearchMemoryInput): Promise<unknown>;
-  get(input: GetMemoryInput): Promise<unknown>;
+  search(input: SearchMemoryInput): Promise<Search>;
+  get(input: GetMemoryInput): Promise<Search>;
   forget(input: ForgetMemoryInput): Promise<unknown>;
   batch(input: StoreMemoryInput[]): Promise<unknown>;
-  compress(input: CompressMemoryInput): Promise<CompressMemoryApiResponse>;
+  context(input: BuildContextInput): Promise<Context>;
+  files(input: UploadFileInput): Promise<unknown>;
+  compress(input: CompressMemoryInput): Promise<Compress>;
 }
 //#endregion
-export { Lumi0 };
+export { BuildContextInput, Compress, CompressMemoryInput, Context, ErrorResponse, ForgetMemoryInput, GetMemoryInput, HttpClientOptions, IPostBody, Lumi0, Lumi0Options, MemoryRollbackInput, MemoryVersion, PostBody, Search, SearchMemoryInput, StoreMemoryInput, UploadFileInput };

package/dist/index.mjs

@@ -36,12 +36,6 @@ var HttpClient = class {
 			body: body ? JSON.stringify(body) : void 0
 		});
 	}
-	list(path, items) {
-		return this.request(path, {
-			method: "POST",
-			body: JSON.stringify(items)
-		});
-	}
 	put(path, body) {
 		return this.request(path, {
 			method: "PUT",
@@ -72,9 +66,24 @@ var HttpClient = class {
 	}
 };
 //#endregion
+//#region src/memory.ts
+var MemoryApi = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	history(id) {
+		return this.http.get(`/memories/history/${id}`).then((response) => response.data);
+	}
+	rollback(input) {
+		return this.http.post(`/memories/${input.memoryId}/versions/${input.version}/rollback`);
+	}
+};
+//#endregion
 //#region src/client.ts
 var Lumi0 = class {
 	http;
+	mem;
 	constructor(option) {
 		const apiKey = option.apiKey;
 		this.http = new HttpClient({
@@ -82,6 +91,7 @@ var Lumi0 = class {
 			apiKey,
 			timeout: option.timeout ?? 3e4
 		});
+		this.mem = new MemoryApi(this.http);
 	}
 	store(input) {
 		return this.http.post("/memory", {
@@ -93,10 +103,10 @@ var Lumi0 = class {
 		return this.http.post("/memory/search", {
 			...input,
 			externalId: input.id
-		});
+		}).then((res) => res.data);
 	}
 	get(input) {
-		return this.http.post("/memory/get", input);
+		return this.http.post("/memory/get", input).then((res) => res.data);
 	}
 	forget(input) {
 		return this.http.delete(`/memory/${input.id}`);
@@ -104,8 +114,20 @@ var Lumi0 = class {
 	batch(input) {
 		return this.http.post("/memory/batch", input.map((item) => ({ ...item })));
 	}
+	context(input) {
+		return this.http.post("/memory/context", {
+			...input,
+			externalId: input.id
+		}).then((res) => res.data);
+	}
+	files(input) {
+		return this.http.post("/memory/batch", {
+			...input,
+			externalId: input.id
+		});
+	}
 	compress(input) {
-		return this.http.post("/compress", input);
+		return this.http.post("/compress", input).then((res) => res.data);
 	}
 };
 //#endregion

package/package.json

@@ -1,9 +1,11 @@
 {
 	"name": "@lumi0/sdk",
-	"version": "0.0.3",
+	"version": "0.0.5",
 	"description": "Official TypeScript SDK for Lumi0",
 	"type": "module",
 	"license": "MIT",
+	"main": "./dist/index.mjs",
+	"types": "./dist/index.d.mts",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/lumi0ai/lumi0-ts.git"