@lumi0/sdk 0.0.4 → 0.0.5

package/README.md

@@ -1,8 +1,8 @@
 # Lumi0 TypeScript SDK
 
-The official TypeScript SDK for [Lumi0](https://lumi0.com), an AI infrastructure platform for persistent memory and context compression.
+The official TypeScript SDK for [Lumi0](https://lumi0.com), an AI infrastructure platform for persistent memory, context compression, and document ingestion.
 
-Use Lumi0 to give AI applications long-term memory: store information about users, retrieve relevant context with semantic search, manage memory versions, batch-write memories, forget stored information, and compress large contexts before sending them to an LLM.
+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
 
@@ -13,6 +13,8 @@ Use Lumi0 to give AI applications long-term memory: store information about user
 * 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
@@ -52,7 +54,7 @@ Create a Lumi0 client:
 import { Lumi0 } from "@lumi0/sdk";
 
 const client = new Lumi0({
-	apiKey: process.env.LUMI0_API_KEY!,
+    apiKey: process.env.LUMI0_API_KEY!,
 });
 ```
 
@@ -62,8 +64,8 @@ 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.",
 });
 ```
 
@@ -73,14 +75,27 @@ 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
@@ -88,9 +103,10 @@ User
   ↓
 Your AI Application
   ↓
-Lumi0 Memory
-  ↓
-Semantic Search
+Lumi0
+  ├── Memory
+  ├── File Ingestion
+  └── Context Compression
   ↓
 Relevant Context
   ↓
@@ -107,8 +123,8 @@ Stores a single memory for an identifier.
 
 ```ts
 await client.store({
-	id: "user_123",
-	content: "The user uses Bun and TypeScript.",
+    id: "user_123",
+    content: "The user uses Bun and TypeScript.",
 });
 ```
 
@@ -116,9 +132,9 @@ You can optionally configure deduplication:
 
 ```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.",
+    dedupeThreshold: 0.9,
 });
 ```
 
@@ -130,18 +146,18 @@ 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 uses Bun for backend services.",
-	},
+    {
+        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.",
+    },
 ]);
 ```
 
@@ -151,18 +167,18 @@ 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.",
-	},
+    {
+        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.",
+    },
 ]);
 ```
 
@@ -172,11 +188,11 @@ 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",
 });
 ```
 
@@ -188,9 +204,9 @@ 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",
+    id: "user_123",
+    query: "What does the user know about this project?",
+    memoryType: "semantic",
 });
 ```
 
@@ -200,7 +216,7 @@ Retrieves a memory by its identifier.
 
 ```ts
 const memory = await client.get({
-	id: "memory_123",
+    id: "memory_123",
 });
 ```
 
@@ -208,8 +224,8 @@ To retrieve a specific version:
 
 ```ts
 const memory = await client.get({
-	id: "memory_123",
-	version: 2,
+    id: "memory_123",
+    version: 2,
 });
 ```
 
@@ -221,10 +237,59 @@ Deletes a stored memory.
 
 ```ts
 await client.forget({
-	id: "memory_123",
+    id: "memory_123",
+});
+```
+
+### `files()`
+
+Uploads and ingests a document from a URL.
+
+```ts
+const upload = await client.files({
+    url: "https://example.com/document.pdf",
+    id: "tenant_123",
+});
+```
+
+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()`
 
@@ -234,10 +299,10 @@ 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);
@@ -248,10 +313,10 @@ 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,
+    content: JSON.stringify(memories),
+    query: "What is the user's preferred backend stack?",
+    mode: "adaptive",
+    budgetRatio: 0.5,
 });
 
 const context = result.data.compressedText;
@@ -261,16 +326,16 @@ const context = result.data.compressedText;
 
 #### Compression modes
 
-Lumi0 supports two compression modes:
+Lumi0 supports two compression modes.
 
 **Adaptive**
 
 ```ts
 await client.compress({
-	content,
-	query,
-	mode: "adaptive",
-	budgetRatio: 0.5,
+    content,
+    query,
+    mode: "adaptive",
+    budgetRatio: 0.5,
 });
 ```
 
@@ -280,10 +345,10 @@ Adaptive compression allows Lumi0 to determine how much context should be retain
 
 ```ts
 await client.compress({
-	content,
-	query,
-	mode: "fixed",
-	budgetRatio: 0.5,
+    content,
+    query,
+    mode: "fixed",
+    budgetRatio: 0.5,
 });
 ```
 
@@ -299,42 +364,62 @@ A typical application can combine `store()` and `search()`:
 import { Lumi0 } from "@lumi0/sdk";
 
 const client = new Lumi0({
-	apiKey: process.env.LUMI0_API_KEY!,
+    apiKey: process.env.LUMI0_API_KEY!,
 });
 
 // Save information learned from the conversation.
 await client.store({
-	id: "user_123",
-	content: "The user prefers concise answers.",
+    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,
+    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,
+    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,
+    content: JSON.stringify(memories),
+    query: "What does the user prefer when writing code?",
+    mode: "adaptive",
+    budgetRatio: 0.5,
 });
 
 const context = compressed.data.compressedText;
@@ -364,9 +449,9 @@ 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: process.env.LUMI0_API_KEY!,
+    baseUrl: "https://api.lumi0.com/api/v1",
+    timeout: 30_000,
 });
 ```
 
@@ -392,8 +477,8 @@ You can override it:
 
 ```ts
 const client = new Lumi0({
-	apiKey: process.env.LUMI0_API_KEY!,
-	baseUrl: "https://api.lumi0.com/api/v1",
+    apiKey: process.env.LUMI0_API_KEY!,
+    baseUrl: "https://api.lumi0.com/api/v1",
 });
 ```
 
@@ -413,8 +498,8 @@ Example:
 
 ```ts
 const client = new Lumi0({
-	apiKey: process.env.LUMI0_API_KEY!,
-	timeout: 60_000,
+    apiKey: process.env.LUMI0_API_KEY!,
+    timeout: 60_000,
 });
 ```
 
@@ -432,7 +517,7 @@ Then:
 import { Lumi0 } from "@lumi0/sdk";
 
 const client = new Lumi0({
-	apiKey: process.env.LUMI0_API_KEY!,
+    apiKey: process.env.LUMI0_API_KEY!,
 });
 ```
 
@@ -446,21 +531,21 @@ Use `try/catch` around SDK operations:
 
 ```ts
 try {
-	const memories = await client.search({
-		id: "user_123",
-		query: "What does the user prefer?",
-		limit: 5,
-	});
+    const memories = await client.search({
+        id: "user_123",
+        query: "What does the user prefer?",
+        limit: 5,
+    });
 
-	console.log(memories);
+    console.log(memories);
 } catch (error) {
-	console.error("Lumi0 request failed:", 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, you should handle failures explicitly rather than assuming every memory operation succeeds.
+For production applications, handle failures explicitly rather than assuming every operation succeeds.
 
 ## Server-Side Usage
 
@@ -471,7 +556,7 @@ Recommended:
 ```ts
 // Server-side code
 const client = new Lumi0({
-	apiKey: process.env.LUMI0_API_KEY!,
+    apiKey: process.env.LUMI0_API_KEY!,
 });
 ```
 
@@ -480,7 +565,7 @@ 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",
+    apiKey: "your-secret-api-key",
 });
 ```
 
@@ -492,18 +577,18 @@ A simple chat application can save user preferences:
 
 ```ts
 await client.store({
-	id: "user_123",
-	content: "The user prefers concise responses.",
+    id: "user_123",
+    content: "The user prefers concise responses.",
 });
 
 await client.store({
-	id: "user_123",
-	content: "The user prefers TypeScript examples.",
+    id: "user_123",
+    content: "The user prefers TypeScript examples.",
 });
 
 await client.store({
-	id: "user_123",
-	content: "The user uses Bun.",
+    id: "user_123",
+    content: "The user uses Bun.",
 });
 ```
 
@@ -511,9 +596,9 @@ 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,
+    id: "user_123",
+    query: "What should I know about this user's coding preferences?",
+    limit: 10,
 });
 ```
 
@@ -523,18 +608,18 @@ 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.",
-	},
+    {
+        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.",
+    },
 ]);
 ```
 
@@ -542,9 +627,9 @@ 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,
+    id: "user_123",
+    query: "What technical preferences should I consider?",
+    limit: 5,
 });
 ```
 
@@ -556,13 +641,13 @@ The SDK is designed for TypeScript applications and provides typed method interf
 import { Lumi0 } from "@lumi0/sdk";
 
 const client = new Lumi0({
-	apiKey: process.env.LUMI0_API_KEY!,
+    apiKey: process.env.LUMI0_API_KEY!,
 });
 
 const result = await client.search({
-	id: "user_123",
-	query: "What does the user prefer?",
-	limit: 5,
+    id: "user_123",
+    query: "What does the user prefer?",
+    limit: 5,
 });
 ```
 
@@ -589,14 +674,15 @@ 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                       |
-| `compress()` | Compress context relevant to a query  |
+| 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
 
@@ -604,45 +690,53 @@ npm install @lumi0/sdk
 import { Lumi0 } from "@lumi0/sdk";
 
 const client = new Lumi0({
-	apiKey: process.env.LUMI0_API_KEY!,
+    apiKey: process.env.LUMI0_API_KEY!,
 });
 
 async function main() {
-	// 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`);
+    // 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);

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

@@ -66,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({
@@ -76,6 +91,7 @@ var Lumi0 = class {
 			apiKey,
 			timeout: option.timeout ?? 3e4
 		});
+		this.mem = new MemoryApi(this.http);
 	}
 	store(input) {
 		return this.http.post("/memory", {
@@ -87,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}`);
@@ -98,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,6 +1,6 @@
 {
 	"name": "@lumi0/sdk",
-	"version": "0.0.4",
+	"version": "0.0.5",
 	"description": "Official TypeScript SDK for Lumi0",
 	"type": "module",
 	"license": "MIT",