@functional-systems/memdrive 0.0.0-stage → 0.1.0-dev.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (97) hide show
  1. package/CHANGELOG.md +14 -0
  2. package/LICENSE +201 -0
  3. package/README.md +232 -2
  4. package/dist/commonjs/chunking.d.ts +7 -0
  5. package/dist/commonjs/chunking.d.ts.map +1 -0
  6. package/dist/commonjs/chunking.js +46 -0
  7. package/dist/commonjs/chunking.js.map +1 -0
  8. package/dist/commonjs/errors.d.ts +17 -0
  9. package/dist/commonjs/errors.d.ts.map +1 -0
  10. package/dist/commonjs/errors.js +44 -0
  11. package/dist/commonjs/errors.js.map +1 -0
  12. package/dist/commonjs/filter.d.ts +30 -0
  13. package/dist/commonjs/filter.d.ts.map +1 -0
  14. package/dist/commonjs/filter.js +224 -0
  15. package/dist/commonjs/filter.js.map +1 -0
  16. package/dist/commonjs/index.d.ts +8 -0
  17. package/dist/commonjs/index.d.ts.map +1 -0
  18. package/dist/commonjs/index.js +343 -0
  19. package/dist/commonjs/index.js.map +1 -0
  20. package/dist/commonjs/package.json +3 -0
  21. package/dist/commonjs/storage.d.ts +274 -0
  22. package/dist/commonjs/storage.d.ts.map +1 -0
  23. package/dist/commonjs/storage.js +861 -0
  24. package/dist/commonjs/storage.js.map +1 -0
  25. package/dist/commonjs/tools/definitions.d.ts +5 -0
  26. package/dist/commonjs/tools/definitions.d.ts.map +1 -0
  27. package/dist/commonjs/tools/definitions.js +129 -0
  28. package/dist/commonjs/tools/definitions.js.map +1 -0
  29. package/dist/commonjs/tools/index.d.ts +6 -0
  30. package/dist/commonjs/tools/index.d.ts.map +1 -0
  31. package/dist/commonjs/tools/index.js +104 -0
  32. package/dist/commonjs/tools/index.js.map +1 -0
  33. package/dist/commonjs/tools/types.d.ts +50 -0
  34. package/dist/commonjs/tools/types.d.ts.map +1 -0
  35. package/dist/commonjs/tools/types.js +3 -0
  36. package/dist/commonjs/tools/types.js.map +1 -0
  37. package/dist/commonjs/types.d.ts +277 -0
  38. package/dist/commonjs/types.d.ts.map +1 -0
  39. package/dist/commonjs/types.js +3 -0
  40. package/dist/commonjs/types.js.map +1 -0
  41. package/dist/commonjs/values.d.ts +17 -0
  42. package/dist/commonjs/values.d.ts.map +1 -0
  43. package/dist/commonjs/values.js +90 -0
  44. package/dist/commonjs/values.js.map +1 -0
  45. package/dist/esm/chunking.d.ts +7 -0
  46. package/dist/esm/chunking.d.ts.map +1 -0
  47. package/dist/esm/chunking.js +42 -0
  48. package/dist/esm/chunking.js.map +1 -0
  49. package/dist/esm/errors.d.ts +17 -0
  50. package/dist/esm/errors.d.ts.map +1 -0
  51. package/dist/esm/errors.js +36 -0
  52. package/dist/esm/errors.js.map +1 -0
  53. package/dist/esm/filter.d.ts +30 -0
  54. package/dist/esm/filter.d.ts.map +1 -0
  55. package/dist/esm/filter.js +209 -0
  56. package/dist/esm/filter.js.map +1 -0
  57. package/dist/esm/index.d.ts +8 -0
  58. package/dist/esm/index.d.ts.map +1 -0
  59. package/dist/esm/index.js +335 -0
  60. package/dist/esm/index.js.map +1 -0
  61. package/dist/esm/package.json +3 -0
  62. package/dist/esm/storage.d.ts +274 -0
  63. package/dist/esm/storage.d.ts.map +1 -0
  64. package/dist/esm/storage.js +845 -0
  65. package/dist/esm/storage.js.map +1 -0
  66. package/dist/esm/tools/definitions.d.ts +5 -0
  67. package/dist/esm/tools/definitions.d.ts.map +1 -0
  68. package/dist/esm/tools/definitions.js +126 -0
  69. package/dist/esm/tools/definitions.js.map +1 -0
  70. package/dist/esm/tools/index.d.ts +6 -0
  71. package/dist/esm/tools/index.d.ts.map +1 -0
  72. package/dist/esm/tools/index.js +101 -0
  73. package/dist/esm/tools/index.js.map +1 -0
  74. package/dist/esm/tools/types.d.ts +50 -0
  75. package/dist/esm/tools/types.d.ts.map +1 -0
  76. package/dist/esm/tools/types.js +2 -0
  77. package/dist/esm/tools/types.js.map +1 -0
  78. package/dist/esm/types.d.ts +277 -0
  79. package/dist/esm/types.d.ts.map +1 -0
  80. package/dist/esm/types.js +2 -0
  81. package/dist/esm/types.js.map +1 -0
  82. package/dist/esm/values.d.ts +17 -0
  83. package/dist/esm/values.d.ts.map +1 -0
  84. package/dist/esm/values.js +87 -0
  85. package/dist/esm/values.js.map +1 -0
  86. package/docs/tools.md +163 -0
  87. package/package.json +99 -4
  88. package/src/chunking.ts +32 -0
  89. package/src/errors.ts +40 -0
  90. package/src/filter.ts +189 -0
  91. package/src/index.ts +323 -0
  92. package/src/storage.ts +765 -0
  93. package/src/tools/definitions.ts +156 -0
  94. package/src/tools/index.ts +97 -0
  95. package/src/tools/types.ts +45 -0
  96. package/src/types.ts +273 -0
  97. package/src/values.ts +103 -0
package/src/index.ts ADDED
@@ -0,0 +1,323 @@
1
+ // Application-facing memory storage and retrieval. No answer assembly lives here.
2
+ import type { Backend, DataBackend, Evidence, VectorEvidence } from './storage.js';
3
+ import type {
4
+ CreateOptions, OpenOptions, RequestOptions, RecallRequest, TextRecallRequest, RecallResult,
5
+ BatchRecallResult, MetadataSchema, EmbeddingConfig, TextSearch, Usage, Observation, RecordEvent,
6
+ MemInput, ForgetRequest, ConfigureRequest, BranchRequest, CatalogRequest, CatalogResult,
7
+ ListRequest, MemDrive, DriveData, CountValuesRequest,
8
+ } from './types.js';
9
+ import { createBackend, openBackend, listBackends, validateChunk, publicMatch, validateVector, vectorMatch } from './storage.js';
10
+ import { buildSearchFilter, validateFilter, matchesFilter } from './filter.js';
11
+ import { MemDriveError, requireInput, operationOptions, checkAbort, abortError } from './errors.js';
12
+ import { createValueCounter } from './values.js';
13
+
14
+ export type * from './types.js';
15
+ export { MemDriveError } from './errors.js';
16
+
17
+ type Options = (CreateOptions | OpenOptions) & { branch?: string | undefined; embedding?: CreateOptions['embedding']; textSearch?: TextSearch | undefined };
18
+ type Queue = <T>(operation: () => Promise<T>, signal?: AbortSignal) => Promise<T>;
19
+ type QueryBody = Parameters<DataBackend['query']>[0];
20
+ type NativeResponse = Awaited<ReturnType<DataBackend['query']>>;
21
+ type NormalizedResponse = Omit<NativeResponse, 'docs'> & { docs: Array<Omit<NativeResponse['docs'][number], 'doc'> & { doc: Evidence | VectorEvidence }> };
22
+ type ValidRecall = RecallRequest & { limit: number };
23
+ type PreparedRecall = { input: unknown; start: number; error?: never } | { error: MemDriveError; input?: never; start?: never };
24
+
25
+ const keys = (value: unknown, allowed: string[]): value is Record<string, unknown> => value !== null && typeof value === 'object' && !Array.isArray(value)
26
+ && Object.keys(value).every(key => allowed.includes(key));
27
+ const nonempty = (value: unknown): value is string => typeof value === 'string' && value.trim().length > 0;
28
+
29
+ function validateOptions<T extends Options>(options: T, creating: boolean): T {
30
+ requireInput(keys(options, ['client', 'name', 'maxConcurrentRequests', 'observe', 'record',
31
+ ...(creating ? ['metadataSchema', 'textSearch', 'embedding', 'labels', 'description'] : ['branch'])]), 'Use the documented MemDrive options.');
32
+ requireInput(creating || options.branch === undefined || (typeof options.branch === 'string'
33
+ && /^[A-Za-z0-9_-]{3,52}$/.test(options.branch)), 'branch must be a valid branch name.');
34
+ if (creating && options.embedding?.mode === 'external')
35
+ requireInput(options.textSearch === undefined, 'External embeddings do not support textSearch.');
36
+ const concurrency = options.maxConcurrentRequests ?? 5;
37
+ requireInput(Number.isSafeInteger(concurrency) && concurrency > 0, 'maxConcurrentRequests must be a positive integer.');
38
+ for (const name of ['observe', 'record'] as const)
39
+ requireInput(options[name] === undefined || typeof options[name] === 'function', `${name} must be a callback.`);
40
+ return { ...options };
41
+ }
42
+
43
+ // Separate queues bound logical recalls and database work across all branch views.
44
+ function requestQueue(limit: number): Queue {
45
+ let active = 0;
46
+ const waiting: Array<{ start(): void }> = [];
47
+ return <T>(operation: () => Promise<T>, signal?: AbortSignal) => new Promise<T>((resolve, reject) => {
48
+ try { checkAbort(signal); } catch (error) { reject(error); return; }
49
+ const entry = { start() {
50
+ signal?.removeEventListener('abort', cancel);
51
+ active++;
52
+ Promise.resolve().then(() => { checkAbort(signal); return operation(); }).then(resolve, reject).finally(() => {
53
+ active--;
54
+ waiting.shift()?.start();
55
+ });
56
+ } };
57
+ const cancel = () => {
58
+ const index = waiting.indexOf(entry);
59
+ if (index < 0) return;
60
+ waiting.splice(index, 1);
61
+ signal?.removeEventListener('abort', cancel);
62
+ reject(abortError(undefined, signal));
63
+ };
64
+ if (active < limit) entry.start();
65
+ else {
66
+ waiting.push(entry);
67
+ signal?.addEventListener('abort', cancel, { once: true });
68
+ if (signal?.aborted) cancel();
69
+ }
70
+ });
71
+ }
72
+
73
+ function recallInput(request: unknown, schema: MetadataSchema, embedding: EmbeddingConfig): ValidRecall {
74
+ const external = embedding.mode === 'external';
75
+ requireInput(keys(request, [...(external ? ['queryVector'] : ['query', 'recentDialogue', 'context']), 'filter', 'excludeIds', 'limit', 'rerank']),
76
+ 'Use the documented recall arguments.');
77
+ if (external) {
78
+ validateVector(request.queryVector, embedding);
79
+ } else requireInput(nonempty(request.query) && request.query.trim() !== '*:*', 'query must be nonempty text other than the exact match-all expression *:*.');
80
+ requireInput(request.context === undefined || typeof request.context === 'string', 'context must be text.');
81
+ requireInput(request.recentDialogue === undefined || (Array.isArray(request.recentDialogue)
82
+ && request.recentDialogue.every(message => keys(message, ['role', 'content'])
83
+ && typeof message.role === 'string' && ['user', 'assistant'].includes(message.role) && typeof message.content === 'string')),
84
+ 'recentDialogue must contain role-labelled user/assistant text.');
85
+ requireInput(request.rerank === undefined || typeof request.rerank === 'boolean', 'rerank must be a boolean.');
86
+ requireInput(request.excludeIds === undefined || (Array.isArray(request.excludeIds)
87
+ && request.excludeIds.every(nonempty) && new Set(request.excludeIds).size === request.excludeIds.length),
88
+ 'excludeIds must contain distinct canonical IDs.');
89
+ const limit = request.limit ?? 10;
90
+ requireInput(typeof limit === 'number' && Number.isSafeInteger(limit) && limit >= 1 && limit <= 1000, 'limit must be between 1 and 1000.');
91
+ validateFilter(request.filter, schema);
92
+ return { ...structuredClone(request), limit } as ValidRecall;
93
+ }
94
+
95
+ export function contextualQuery(request: TextRecallRequest): string {
96
+ if (!request.recentDialogue?.length && !request.context) return request.query;
97
+ return JSON.stringify({ question: request.query,
98
+ ...(request.recentDialogue?.length ? { recent_dialogue: request.recentDialogue } : {}),
99
+ ...(request.context ? { context: request.context } : {}) });
100
+ }
101
+
102
+ function recallQuery(request: ValidRecall, schema: MetadataSchema, textSearch: TextSearch | undefined, embedding: EmbeddingConfig): QueryBody {
103
+ if (embedding.mode === 'external') return { size: request.limit, query: { knn: {
104
+ field: 'embedding', queryVector: request.queryVector, k: request.limit,
105
+ filter: buildSearchFilter([request.filter], request.excludeIds ?? [], [], schema),
106
+ } } };
107
+ const context = contextualQuery(request as TextRecallRequest);
108
+ // Native text-query input bound, not a silent SDK context truncation policy.
109
+ requireInput(new TextEncoder().encode(request.query).length <= 8192 && new TextEncoder().encode(context).length <= 8192,
110
+ 'The contextual search query exceeds the native 8 KiB limit.');
111
+ const filter = buildSearchFilter([request.filter], request.excludeIds ?? [], [], schema);
112
+ const candidates = Math.max(200, request.limit);
113
+ const semantic = { knn: { field: 'embedding', queryText: context, k: candidates, filter } };
114
+ const query = textSearch ? { bayesian: [semantic,
115
+ { bool: [{ ...filter, occur: 'filter' },
116
+ { queryString: { query: request.query, defaultField: 'content', skipSyntax: true }, occur: 'must' }] },
117
+ ] } : semantic;
118
+ return { size: request.limit, query, ...(request.rerank === false ? (textSearch ? { candidateSize: candidates } : {}) : {
119
+ rerank: { provider: 'typesafe', model: 'jev-1.13.0', queryText: context,
120
+ fields: ['content'], candidateSize: candidates, onFailure: 'error' },
121
+ }) };
122
+ }
123
+
124
+ async function validatedHits(response: NativeResponse, request: ValidRecall, schema: MetadataSchema, name: string, max: number, embedding: EmbeddingConfig): Promise<Array<Evidence | VectorEvidence>> {
125
+ if (response?.isDocsInline === false || !Array.isArray(response?.docs) || response.docs.length > max)
126
+ throw new MemDriveError('INVALID_RESULT', 'Search returned an invalid document envelope.');
127
+ const seen = new Set<string>();
128
+ return Promise.all(response.docs.map(async hit => {
129
+ if (hit.collection !== undefined && hit.collection !== name)
130
+ throw new MemDriveError('INVALID_RESULT', 'Search returned a different collection.');
131
+ let mem;
132
+ try { mem = await (embedding.mode === 'external' ? vectorMatch(hit.doc, schema) : validateChunk(hit.doc, schema)); }
133
+ catch (cause) { throw new MemDriveError('INVALID_RESULT', 'Search returned invalid Mem evidence.', { cause }); }
134
+ if (seen.has(mem.id) || request.excludeIds?.includes(mem.memId) || !matchesFilter({ ...mem, id: mem.memId }, request.filter, schema))
135
+ throw new MemDriveError('INVALID_RESULT', 'Search returned duplicate, excluded or filtered-out evidence.');
136
+ seen.add(mem.id);
137
+ return mem;
138
+ }));
139
+ }
140
+
141
+ function verifyRerank(response: NormalizedResponse, body: QueryBody) {
142
+ const result = response.rerank;
143
+ const same = result?.provider === body.rerank!.provider && result?.model === body.rerank!.model;
144
+ const applied = result?.status === 'applied' && Number.isSafeInteger(result.candidateCount)
145
+ && result.scoredCount === result.candidateCount && result.candidateCount !== undefined && result.candidateCount >= response.docs.length
146
+ && result.candidateCount <= body.rerank!.candidateSize!
147
+ && response.docs.every(hit => typeof hit.score === 'number' && Number.isFinite(hit.score) && hit.score >= 0 && hit.score <= 1);
148
+ const empty = result?.status === 'skipped' && result.reason === 'noCandidates'
149
+ && result.candidateCount === 0 && result.scoredCount === 0 && response.docs.length === 0;
150
+ if (!same || (!applied && !empty)) throw new MemDriveError('RERANK_FAILED', 'Native reranking was not confirmed.');
151
+ }
152
+
153
+ function makeDataHandle(backend: DataBackend, options: Options, queue: Queue, recallQueue: Queue): DriveData {
154
+ const counter = createValueCounter({ describe: options => backend.describe(options), query: (body, options) => backend.query(body, options),
155
+ metadataSchema: () => backend.metadataSchema });
156
+ let generation = backend.generation;
157
+ const invalidate = () => { generation = backend.generation; counter.invalidate(); };
158
+ const inspect = async <T>(operation: () => Promise<T>): Promise<T> => {
159
+ backend.assertActive();
160
+ if (generation !== backend.generation) invalidate();
161
+ try { const result = await operation(); backend.assertActive(); return result; }
162
+ finally { if (generation !== backend.generation) invalidate(); }
163
+ };
164
+ const mutation = async <T>(operation: () => Promise<T>): Promise<T> => {
165
+ try { return await operation(); }
166
+ finally { invalidate(); }
167
+ };
168
+ const executeRecall = async (input: unknown, start: number, requestIndex?: number, signal?: AbortSignal): Promise<RecallResult> => {
169
+ const usage: Usage = { elapsedMs: 0, databaseRequests: 0 };
170
+ const hook = <T extends Observation | RecordEvent>(callback?: ((event: T) => void | Promise<void>)) => async (event: T) => {
171
+ checkAbort(signal);
172
+ await callback?.(requestIndex === undefined ? event : { ...event, requestIndex });
173
+ checkAbort(signal);
174
+ };
175
+ const record = hook(options.record);
176
+ const observe = hook(options.observe);
177
+ const executeDb = <T>(operation: (options?: RequestOptions) => Promise<T>): Promise<T> => queue(async () => {
178
+ backend.assertActive(); checkAbort(signal);
179
+ usage.databaseRequests++;
180
+ try { const result = await operation({ signal }); checkAbort(signal); return result; }
181
+ catch (cause) {
182
+ const failure = abortError(cause, signal);
183
+ if (failure instanceof MemDriveError) throw failure;
184
+ const error = new MemDriveError('DATABASE_ERROR', 'MemDrive database request failed.', { cause: failure });
185
+ const remote = failure as { statusCode?: number; status?: number };
186
+ error.status = remote.statusCode ?? remote.status;
187
+ throw error;
188
+ }
189
+ }, signal);
190
+ try {
191
+ checkAbort(signal);
192
+ backend.assertActive();
193
+ if (generation !== backend.generation) invalidate();
194
+ const schema = () => backend.metadataSchema;
195
+ const request = recallInput(input, schema(), backend.embedding);
196
+ requireInput(request.rerank !== true || backend.embedding.mode === 'managed',
197
+ 'rerank: true requires managed embeddings.');
198
+ const query = async (body: QueryBody): Promise<NormalizedResponse> => {
199
+ const response = await executeDb(options => backend.query(body, options));
200
+ const mems = await validatedHits(response, request, schema(), options.name, body.size ?? 10, backend.embedding);
201
+ return { ...response, docs: response.docs.map((hit, i) => ({ ...hit, doc: mems[i]! })) };
202
+ };
203
+ const body = recallQuery(request, schema(), backend.textSearch, backend.embedding);
204
+ await record({ phase: 'query', request: structuredClone(body) });
205
+ const response = await query(body);
206
+ if (body.rerank) verifyRerank(response, body);
207
+ const mems = response.docs.map(hit => hit.doc);
208
+ await record({ phase: 'query_result', response: structuredClone(response) });
209
+ await observe({ type: 'retrieved', ids: mems.map(mem => mem.id), matches: mems.map(publicMatch) });
210
+ backend.assertActive(); checkAbort(signal);
211
+ usage.elapsedMs = performance.now() - start;
212
+ return { matches: mems.map(publicMatch), usage };
213
+ } catch (cause) {
214
+ const failure = abortError(cause, signal);
215
+ usage.elapsedMs = performance.now() - start;
216
+ const error = failure instanceof MemDriveError ? failure
217
+ : new MemDriveError('RECALL_FAILED', 'MemDrive retrieval failed.', { cause: failure });
218
+ error.usage = structuredClone(usage);
219
+ throw error;
220
+ }
221
+ };
222
+ const snapshot = (input: unknown): PreparedRecall => {
223
+ const start = performance.now();
224
+ try { return { input: structuredClone(input), start }; }
225
+ catch (cause) {
226
+ const error = new MemDriveError('INVALID_INPUT', 'Recall input must be cloneable data.', { cause });
227
+ error.usage = { elapsedMs: 0, databaseRequests: 0 };
228
+ return { error };
229
+ }
230
+ };
231
+ const submit = async (prepared: PreparedRecall, requestIndex?: number, signal?: AbortSignal): Promise<RecallResult> => {
232
+ if (prepared.error) throw prepared.error;
233
+ try { return await recallQueue(() => executeRecall(prepared.input, prepared.start, requestIndex, signal), signal); }
234
+ catch (cause) {
235
+ // Queue cancellation and executeRecall both reject with MemDriveError.
236
+ const error = cause as MemDriveError;
237
+ error.usage ??= { elapsedMs: performance.now() - prepared.start, databaseRequests: 0 };
238
+ throw error;
239
+ }
240
+ };
241
+ async function recall(input: RecallRequest, options?: RequestOptions): Promise<RecallResult>;
242
+ async function recall(input: { requests: RecallRequest[] }, options?: RequestOptions): Promise<BatchRecallResult>;
243
+ async function recall(input: unknown, options?: RequestOptions): Promise<RecallResult | BatchRecallResult> {
244
+ const { signal } = operationOptions(options);
245
+ if (input !== null && typeof input === 'object' && Object.hasOwn(input, 'requests')) {
246
+ requireInput(keys(input, ['requests']) && Array.isArray(input.requests) && input.requests.length > 0,
247
+ 'Batch recall requires only a nonempty requests array.');
248
+ // Snapshot every item before any operation can yield or mutate caller data.
249
+ const prepared = Array.from(input.requests, snapshot);
250
+ const results = await Promise.all(prepared.map(async (item, requestIndex) => {
251
+ try { return await submit(item, requestIndex, signal); }
252
+ catch (cause) {
253
+ const error = cause as MemDriveError;
254
+ return { error: { code: error.code, message: error.message,
255
+ ...(Number.isInteger(error.status) ? { status: error.status! } : {}) },
256
+ usage: structuredClone(error.usage!) };
257
+ }
258
+ }));
259
+ return { results };
260
+ }
261
+ return submit(snapshot(input), undefined, signal);
262
+
263
+ }
264
+ return Object.freeze({
265
+ remember: (request: { mems: MemInput[] }, options?: RequestOptions) => mutation(() => backend.remember(request, options)),
266
+ forget: (request: ForgetRequest, options?: RequestOptions) => mutation(() => backend.forget(request, options)),
267
+ read: (request: { ids: string[] }, options?: RequestOptions) => backend.read(request, undefined, options),
268
+ list: (request?: ListRequest, options?: RequestOptions) => backend.list(request, options),
269
+ embedding: Object.freeze(structuredClone(backend.embedding)),
270
+ recall,
271
+ async countValues(request: CountValuesRequest, options?: RequestOptions) {
272
+ const { signal } = operationOptions(options);
273
+ checkAbort(signal);
274
+ return inspect(() => counter.countValues(request, operation => queue(async () => {
275
+ backend.assertActive(); checkAbort(signal);
276
+ const result = await operation({ signal });
277
+ backend.assertActive(); checkAbort(signal);
278
+ return result;
279
+ }, signal), signal));
280
+ },
281
+ });
282
+ }
283
+
284
+ function makeDrive(backend: Backend, options: Options): MemDrive {
285
+ const concurrency = options.maxConcurrentRequests ?? 5;
286
+ const queue = requestQueue(concurrency), recallQueue = requestQueue(concurrency);
287
+ const at = (ref: { branch: string }) => {
288
+ requireInput(keys(ref, ['branch']) && Object.hasOwn(ref, 'branch'), 'Select a branch with { branch }.');
289
+ return makeDataHandle(backend.at(ref.branch), options, queue, recallQueue);
290
+ };
291
+ return Object.freeze({
292
+ ...at({ branch: options.branch ?? 'main' }),
293
+ at,
294
+ branches: Object.freeze({
295
+ create: (request: BranchRequest, options?: RequestOptions) => backend.branches.create(request, options),
296
+ list: (options?: RequestOptions) => backend.branches.list(options),
297
+ delete: (name: string, options?: RequestOptions) => backend.branches.delete(name, options),
298
+ }),
299
+ configure: (request: ConfigureRequest, options?: RequestOptions) => backend.configure(request, options),
300
+ destroy: (options?: RequestOptions) => backend.destroy(options),
301
+ describe: (options?: RequestOptions) => backend.describeDescriptor(options),
302
+ });
303
+ }
304
+
305
+ export async function create(options: CreateOptions, requestOptions?: RequestOptions): Promise<MemDrive> {
306
+ requestOptions = operationOptions(requestOptions); checkAbort(requestOptions.signal);
307
+ options = validateOptions(options, true);
308
+ const backend = await createBackend({ client: options.client, name: options.name, metadataSchema: options.metadataSchema, textSearch: options.textSearch, embedding: options.embedding, labels: options.labels,
309
+ description: options.description }, requestOptions);
310
+ return makeDrive(backend, options);
311
+ }
312
+
313
+ export async function open(options: OpenOptions, requestOptions?: RequestOptions): Promise<MemDrive> {
314
+ requestOptions = operationOptions(requestOptions); checkAbort(requestOptions.signal);
315
+ options = validateOptions(options, false);
316
+ const backend = await openBackend({ client: options.client, name: options.name }, requestOptions);
317
+ if (options.branch !== undefined && options.branch !== 'main'
318
+ && !(await backend.branches.list(requestOptions)).some(branch => branch.name === options.branch))
319
+ throw new MemDriveError('BRANCH_NOT_FOUND', 'The selected MemDrive branch does not exist.');
320
+ return makeDrive(backend, options);
321
+ }
322
+
323
+ export const list = (request: CatalogRequest, options?: RequestOptions): Promise<CatalogResult> => listBackends(request, options);