@scitrera/memorylayer-sdk 0.0.5 → 0.2.0

package/dist/client.js

@@ -1,16 +1,51 @@
-import { MemoryLayerError, AuthenticationError, AuthorizationError, NotFoundError, ValidationError } from "./errors.js";
+import { MemoryLayerError, AuthenticationError, AuthorizationError, NotFoundError, ValidationError, EnterpriseRequiredError, RateLimitError } from "./errors.js";
+import { sleep } from "./utils.js";
+import { SkillsNamespace } from "./skills.js";
+import { McpServersNamespace } from "./mcp_servers.js";
+import { KnowledgebaseNamespace } from "./knowledgebase.js";
+import { RpgNamespace } from "./rpg.js";
 export class MemoryLayerClient {
     baseUrl;
     apiKey;
     workspaceId;
     sessionId;
     timeout;
+    defaultAuthority;
+    fetchImpl;
+    maxRetries;
+    retryBaseDelay;
+    /** Skills namespace — access via `client.skills.list(...)` etc. */
+    skills;
+    /** MCP Servers namespace — access via `client.mcpServers.list(...)` etc. */
+    mcpServers;
+    /** Knowledgebase namespace — access via `client.kb.get(...)` etc. */
+    kb;
+    /** Repository Planning Graph namespace — access via `client.rpg.sync(...)` etc. */
+    rpg;
     constructor(config = {}) {
         this.baseUrl = config.baseUrl ?? "http://localhost:61001";
         this.apiKey = config.apiKey;
         this.workspaceId = config.workspaceId;
         this.sessionId = config.sessionId;
         this.timeout = config.timeout ?? 30000;
+        this.defaultAuthority = config.defaultAuthority;
+        this.maxRetries = config.maxRetries ?? 3;
+        this.retryBaseDelay = config.retryBaseDelay ?? 500;
+        // Bind to globalThis so the default impl preserves `this === undefined`
+        // (fetch is sensitive to its receiver in some runtimes).
+        this.fetchImpl = config.fetch ?? fetch.bind(globalThis);
+        this.skills = new SkillsNamespace(this);
+        this.mcpServers = new McpServersNamespace(this);
+        this.kb = new KnowledgebaseNamespace(this);
+        this.rpg = new RpgNamespace(this);
+    }
+    /**
+     * Returns a lightweight proxy that sends OBO headers for the given grant/subject
+     * on every request. The proxy is synchronous and reuses the parent client's
+     * connection settings — safe for concurrent use across multiple subjects.
+     */
+    actingFor(opts) {
+        return new OboProxy(this, { grantId: opts.grantId, subject: opts.subject });
     }
     /**
      * Set the active session ID. All subsequent requests will include
@@ -32,10 +67,36 @@ export class MemoryLayerClient {
     getSessionId() {
         return this.sessionId;
     }
-    async request(method, path, body) {
-        const headers = {
-            "Content-Type": "application/json",
+    buildAuthorityHeaders(authority) {
+        const resolved = authority ?? this.defaultAuthority;
+        if (!resolved)
+            return {};
+        const h = {
+            "X-Aether-Grant-ID": resolved.grantId,
+            "X-Aether-Authority-Mode": "on_behalf_of",
+            "X-Aether-Subject-Type": resolved.subject.type,
+            "X-Aether-Subject-ID": resolved.subject.id,
         };
+        return h;
+    }
+    /**
+     * Build the standard request headers (auth, session, workspace, OBO authority).
+     * Centralized so every request helper applies identical header logic.
+     *
+     * Note: upload/stream paths (exportWorkspace, importWorkspaceStream,
+     * uploadDocument, uploadDataset, getPageImage) call this method and therefore
+     * intentionally inherit authority (X-Aether-*) headers when a defaultAuthority
+     * is set — consistent with every other request type.
+     *
+     * @param includeContentType Whether to set `Content-Type: application/json`.
+     *   Omit for multipart/form-data (browser sets the boundary) or NDJSON bodies
+     *   that set their own content type.
+     */
+    buildHeaders(authority, includeContentType = true) {
+        const headers = {};
+        if (includeContentType) {
+            headers["Content-Type"] = "application/json";
+        }
         if (this.apiKey) {
             headers["Authorization"] = `Bearer ${this.apiKey}`;
         }
@@ -45,32 +106,124 @@ export class MemoryLayerClient {
         if (this.workspaceId) {
             headers["X-Workspace-ID"] = this.workspaceId;
         }
-        const url = `${this.baseUrl}${path}`;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        try {
-            const response = await fetch(url, {
-                method,
-                headers,
-                body: body ? JSON.stringify(body) : undefined,
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-                await this.handleError(response);
+        Object.assign(headers, this.buildAuthorityHeaders(authority));
+        return headers;
+    }
+    /**
+     * Determine whether a failed response is transient and should be retried.
+     * Retries 429 (rate limit) and 5xx server errors. 501 is treated as a
+     * permanent "not implemented" signal and is never retried.
+     */
+    isRetryableStatus(status) {
+        if (status === 429)
+            return true;
+        if (status === 501)
+            return false;
+        return status >= 500 && status < 600;
+    }
+    /**
+     * Parse a `Retry-After` header (delta-seconds or HTTP-date) into milliseconds.
+     * Returns undefined when absent or unparseable.
+     */
+    parseRetryAfter(response) {
+        const raw = response.headers?.get?.("Retry-After");
+        if (!raw)
+            return undefined;
+        const seconds = Number(raw);
+        if (!Number.isNaN(seconds)) {
+            return Math.max(0, seconds * 1000);
+        }
+        const dateMs = Date.parse(raw);
+        if (!Number.isNaN(dateMs)) {
+            return Math.max(0, dateMs - Date.now());
+        }
+        return undefined;
+    }
+    /**
+     * Returns true when the HTTP method is safe to retry after a transient failure.
+     * POST is excluded to prevent duplicate writes (e.g. duplicate memories/edges
+     * after a post-commit 504). recall/reflect/mergeEntities are POST-but-read or
+     * write-once, but are deliberately left non-retried for safety and consistency
+     * with the Python SDK.
+     */
+    isIdempotentMethod(method) {
+        return ["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "PATCH"].includes(method.toUpperCase());
+    }
+    /**
+     * Execute a fetch with bounded retry-with-backoff for transient failures
+     * (5xx, 429). Honors the `Retry-After` header when present, otherwise uses
+     * exponential backoff. Non-transient failures and successful responses are
+     * returned/raised immediately.
+     *
+     * Retries are gated on method idempotency: only GET/HEAD/OPTIONS/PUT/DELETE/PATCH
+     * are retried. POST is never retried automatically to avoid duplicate writes.
+     *
+     * This is the single network seam used by every request helper, so retry and
+     * header handling stay consistent across the client.
+     */
+    async executeFetch(url, init, enterpriseFeature) {
+        const canRetry = this.isIdempotentMethod(init.method ?? "GET");
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+            try {
+                const response = await this.fetchImpl(url, { ...init, signal: controller.signal });
+                clearTimeout(timeoutId);
+                if (response.ok) {
+                    return response;
+                }
+                // Transient server-side failure: retry if attempts remain AND method is idempotent.
+                if (canRetry && attempt < this.maxRetries && this.isRetryableStatus(response.status)) {
+                    const retryAfter = this.parseRetryAfter(response);
+                    const delay = retryAfter ?? this.retryBaseDelay * Math.pow(2, attempt);
+                    await sleep(delay);
+                    continue;
+                }
+                // Permanent failure, non-idempotent method, or retries exhausted: surface a typed error.
+                await this.handleError(response, enterpriseFeature);
             }
-            if (response.status === 204) {
-                return undefined;
+            catch (error) {
+                clearTimeout(timeoutId);
+                // Typed errors from handleError are terminal — never retry them.
+                if (error instanceof MemoryLayerError)
+                    throw error;
+                // Network/abort error: retry if attempts remain AND method is idempotent.
+                lastError = error;
+                if (canRetry && attempt < this.maxRetries) {
+                    await sleep(this.retryBaseDelay * Math.pow(2, attempt));
+                    continue;
+                }
+                throw new MemoryLayerError(`Request failed: ${error}`);
             }
-            return await response.json();
         }
-        catch (error) {
-            if (error instanceof MemoryLayerError)
-                throw error;
-            throw new MemoryLayerError(`Request failed: ${error}`);
+        // Unreachable in practice, but satisfies the type checker.
+        throw new MemoryLayerError(`Request failed: ${lastError}`);
+    }
+    async request(method, path, body, enterpriseFeature, authority, responseMode = "json") {
+        const headers = this.buildHeaders(authority);
+        const url = `${this.baseUrl}${path}`;
+        const response = await this.executeFetch(url, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+        }, enterpriseFeature);
+        if (response.status === 204) {
+            return undefined;
         }
+        // Non-JSON endpoints (e.g. GET /v1/skills/{id}/manifest → text/markdown,
+        // GET /v1/skills/{id}/files/{path} → text/x-python etc.) must be read as
+        // raw text/bytes; calling response.json() on them throws. Default stays
+        // JSON so existing callers are unaffected.
+        if (responseMode === "text") {
+            return await response.text();
+        }
+        if (responseMode === "arraybuffer") {
+            return await response.arrayBuffer();
+        }
+        return await response.json();
     }
-    async handleError(response) {
+    async handleError(response, enterpriseFeature) {
         const body = await response.json().catch(() => ({}));
         const rawDetail = body.message ?? body.detail ?? response.statusText;
         const message = typeof rawDetail === 'string'
@@ -86,6 +239,15 @@ export class MemoryLayerClient {
             case 400:
             case 422:
                 throw new ValidationError(message, body.details);
+            case 429: {
+                const retryAfterMs = this.parseRetryAfter(response);
+                throw new RateLimitError(message, retryAfterMs !== undefined ? retryAfterMs / 1000 : undefined);
+            }
+            case 501:
+                if (enterpriseFeature) {
+                    throw new EnterpriseRequiredError(enterpriseFeature);
+                }
+                throw new NotFoundError(message);
             default:
                 throw new MemoryLayerError(message, response.status);
         }
@@ -102,9 +264,11 @@ export class MemoryLayerClient {
             tags: options.tags ?? [],
             metadata: options.metadata ?? {},
             associations: options.associations ?? [],
+            relations: options.relations ?? [],
             context_id: options.contextId,
+            user_id: options.userId,
         };
-        const response = await this.request("POST", "/v1/memories", body);
+        const response = await this.request("POST", "/v1/memories", body, undefined, options.authority);
         return response.memory;
     }
     async recall(query, options = {}) {
@@ -127,11 +291,21 @@ export class MemoryLayerClient {
             max_expansion: options.maxExpansion,
             created_after: options.createdAfter?.toISOString(),
             created_before: options.createdBefore?.toISOString(),
+            offset: options.offset,
+            event_after: options.eventAfter?.toISOString(),
+            event_before: options.eventBefore?.toISOString(),
+            time_order: options.timeOrder,
+            include_global: options.includeGlobal,
+            include_global_user: options.includeGlobalUser,
             context: options.conversationContext ?? [],
             rag_threshold: options.ragThreshold,
             detail_level: options.detailLevel,
+            user_id: options.userId,
+            budget_tokens: options.budgetTokens,
+            include_confidence: options.includeConfidence ?? true,
+            include_relations: options.includeRelations ?? true,
         };
-        return this.request("POST", "/v1/memories/recall", body);
+        return this.request("POST", "/v1/memories/recall", body, undefined, options.authority);
     }
     async reflect(query, options = {}) {
         const body = {
@@ -145,8 +319,9 @@ export class MemoryLayerClient {
             subtypes: options.subtypes ?? [],
             tags: options.tags ?? [],
             context_id: options.contextId,
+            user_id: options.userId,
         };
-        return this.request("POST", "/v1/memories/reflect", body);
+        return this.request("POST", "/v1/memories/reflect", body, undefined, options.authority);
     }
     async getMemory(memoryId) {
         const response = await this.request("GET", `/v1/memories/${memoryId}`);
@@ -172,6 +347,54 @@ export class MemoryLayerClient {
         const response = await this.request("GET", `/v1/memories/${memoryId}/associations?direction=${direction}`);
         return response.associations;
     }
+    /**
+     * Update an association's strength and/or metadata.
+     *
+     * `memoryId` must be one of the association's endpoints (source or target);
+     * otherwise the server returns 404. Re-typing an edge is not supported —
+     * delete and recreate instead.
+     */
+    async updateAssociation(memoryId, associationId, updates) {
+        const body = {};
+        if (updates.strength !== undefined)
+            body.strength = updates.strength;
+        if (updates.metadata !== undefined)
+            body.metadata = updates.metadata;
+        await this.request("PATCH", `/v1/memories/${memoryId}/associations/${associationId}`, body);
+    }
+    /**
+     * Delete an association (graph edge) by ID.
+     *
+     * `memoryId` must be one of the association's endpoints (source or target);
+     * otherwise the server returns 404.
+     */
+    async deleteAssociation(memoryId, associationId) {
+        await this.request("DELETE", `/v1/memories/${memoryId}/associations/${associationId}`);
+    }
+    /**
+     * List/browse memories in the workspace ordered by recency (created_at desc).
+     *
+     * Unlike {@link recall} this performs no vector search — it is a plain
+     * filtered enumeration for browsing. Supports limit/offset pagination and
+     * optional type/subtype/tag/context filters.
+     */
+    async listMemories(options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit !== undefined)
+            params.set("limit", String(options.limit));
+        if (options.offset !== undefined)
+            params.set("offset", String(options.offset));
+        if (options.type)
+            params.set("type", String(options.type));
+        if (options.subtype)
+            params.set("subtype", String(options.subtype));
+        if (options.tag)
+            params.set("tag", options.tag);
+        if (options.contextId)
+            params.set("context_id", options.contextId);
+        const query = params.toString();
+        return this.request("GET", `/v1/memories${query ? `?${query}` : ""}`);
+    }
     // Session operations
     /**
      * Create a new session.
@@ -218,6 +441,37 @@ export class MemoryLayerClient {
         const response = await this.request("GET", `/v1/sessions/${sessionId}`);
         return response.session;
     }
+    async createCheckpoint(sessionId, input) {
+        return this.request("POST", `/v1/sessions/${sessionId}/checkpoints`, {
+            transcript_segment: input.transcriptSegment,
+            content_hash: input.contentHash,
+            idempotency_key: input.idempotencyKey,
+            source_kind: input.sourceKind ?? "transcript",
+            source_sequence: input.sourceSequence,
+            source_boundary: input.sourceBoundary,
+        });
+    }
+    async getCheckpoint(sessionId, checkpointId) {
+        return this.request("GET", `/v1/sessions/${sessionId}/checkpoints/${checkpointId}`);
+    }
+    async getContextPack(sessionId, options = {}) {
+        return this.request("POST", `/v1/sessions/${sessionId}/context-pack`, {
+            topic: options.topic,
+            entity_ids: options.entityIds ?? [],
+            entity_names: options.entityNames ?? [],
+            budget_tokens: options.budgetTokens ?? 2048,
+            section_limits: options.sectionLimits,
+            include_directives: options.includeDirectives,
+            include_working_memory: options.includeWorkingMemory,
+            include_recent_activity: options.includeRecentActivity,
+            include_contradictions: options.includeContradictions,
+            include_sandbox_summary: options.includeSandboxSummary,
+            include_checkpoint_recovery: options.includeCheckpointRecovery,
+        });
+    }
+    async getContextDelta(sessionId, cursor, budgetTokens = 2048) {
+        return this.request("POST", `/v1/sessions/${sessionId}/context-delta`, { cursor, budget_tokens: budgetTokens });
+    }
     async deleteSession(sessionId) {
         await this.request("DELETE", `/v1/sessions/${sessionId}`);
     }
@@ -275,8 +529,8 @@ export class MemoryLayerClient {
         return response.briefing;
     }
     // Workspace operations
-    async createWorkspace(name, settings) {
-        const response = await this.request("POST", "/v1/workspaces", { name, settings: settings ?? {} });
+    async createWorkspace(name, settings, tags) {
+        const response = await this.request("POST", "/v1/workspaces", { name, settings: settings ?? {}, tags: tags ?? [] });
         return response.workspace;
     }
     async getWorkspace(workspaceId) {
@@ -286,8 +540,16 @@ export class MemoryLayerClient {
         const response = await this.request("GET", `/v1/workspaces/${id}`);
         return response.workspace;
     }
-    async listWorkspaces() {
-        const response = await this.request("GET", "/v1/workspaces");
+    async listWorkspaces(filter) {
+        let path = "/v1/workspaces";
+        if (filter?.tags && filter.tags.length > 0) {
+            const params = new URLSearchParams();
+            for (const tag of filter.tags)
+                params.append("tags", tag);
+            params.append("match", filter.match ?? "all");
+            path += `?${params.toString()}`;
+        }
+        const response = await this.request("GET", path);
         return response.workspaces;
     }
     async updateWorkspace(workspaceId, updates) {
@@ -306,6 +568,116 @@ export class MemoryLayerClient {
         const response = await this.request("GET", `/v1/workspaces/${this.workspaceId}/contexts`);
         return response.contexts;
     }
+    async deleteContext(contextId, workspaceId) {
+        const wsId = workspaceId ?? this.workspaceId;
+        if (!wsId)
+            throw new ValidationError("Workspace ID required");
+        await this.request("DELETE", `/v1/workspaces/${wsId}/contexts/${contextId}`);
+    }
+    // ------------------------------------------------------------------ //
+    // Entity Registry operations
+    //
+    // Gated server-side by MEMORYLAYER_ENTITY_REGISTRY_ENABLED. When the
+    // registry is disabled the server returns 501, surfaced here as
+    // EnterpriseRequiredError via the `enterpriseFeature` arg.
+    // ------------------------------------------------------------------ //
+    /** List canonical entities in a workspace (deterministic order by id). */
+    async listEntities(options = {}) {
+        const params = new URLSearchParams();
+        const wsId = options.workspaceId ?? this.workspaceId;
+        if (wsId)
+            params.set("workspace_id", wsId);
+        if (options.status)
+            params.set("status", options.status);
+        if (options.limit !== undefined)
+            params.set("limit", String(options.limit));
+        const query = params.toString();
+        return this.request("GET", `/v1/entities${query ? `?${query}` : ""}`, undefined, "Entity registry");
+    }
+    /** Get a single canonical entity by id. */
+    async getEntity(entityId, workspaceId) {
+        const params = new URLSearchParams();
+        const wsId = workspaceId ?? this.workspaceId;
+        if (wsId)
+            params.set("workspace_id", wsId);
+        const query = params.toString();
+        const response = await this.request("GET", `/v1/entities/${entityId}${query ? `?${query}` : ""}`, undefined, "Entity registry");
+        return response.entity;
+    }
+    /**
+     * Resolve a surface name/alias to an existing canonical entity (never
+     * creates). Throws NotFoundError if no entity matches.
+     */
+    async resolveEntity(name, options = {}) {
+        const params = new URLSearchParams();
+        params.set("name", name);
+        if (options.entityType)
+            params.set("entity_type", String(options.entityType));
+        const wsId = options.workspaceId ?? this.workspaceId;
+        if (wsId)
+            params.set("workspace_id", wsId);
+        return this.request("GET", `/v1/entities/resolve?${params.toString()}`, undefined, "Entity registry");
+    }
+    /**
+     * Merge `sourceId` into `targetId`; returns the surviving target entity.
+     * Requires the entity registry to be enabled (501 -> EnterpriseRequiredError).
+     */
+    async mergeEntities(options) {
+        const params = new URLSearchParams();
+        const wsId = options.workspaceId ?? this.workspaceId;
+        if (wsId)
+            params.set("workspace_id", wsId);
+        const query = params.toString();
+        const response = await this.request("POST", `/v1/entities/merge${query ? `?${query}` : ""}`, {
+            source_id: options.sourceId,
+            target_id: options.targetId,
+            reason: options.reason,
+        }, "Entity registry");
+        return response.entity;
+    }
+    // ------------------------------------------------------------------ //
+    // API Token operations (admin scope; gRPC-backed via Aether)
+    // ------------------------------------------------------------------ //
+    /** List API tokens. Set `includeRevoked` to also return revoked tokens. */
+    async listTokens(includeRevoked = false) {
+        const params = new URLSearchParams();
+        if (includeRevoked)
+            params.set("include_revoked", "true");
+        const query = params.toString();
+        const response = await this.request("GET", `/v1/tokens${query ? `?${query}` : ""}`);
+        return response.tokens;
+    }
+    /**
+     * Create a new API token. The returned object includes the plaintext
+     * `token` value, which is only ever available at creation time.
+     */
+    async createToken(options) {
+        const body = { name: options.name };
+        if (options.principalType !== undefined)
+            body.principal_type = options.principalType;
+        if (options.workspacePatterns !== undefined)
+            body.workspace_patterns = options.workspacePatterns;
+        if (options.scopes !== undefined)
+            body.scopes = options.scopes;
+        if (options.expiresInDays !== undefined)
+            body.expires_in_days = options.expiresInDays;
+        return this.request("POST", "/v1/tokens", body);
+    }
+    /** Get details for a single API token. */
+    async getToken(tokenId) {
+        return this.request("GET", `/v1/tokens/${tokenId}`);
+    }
+    /** Delete an API token. */
+    async deleteToken(tokenId) {
+        await this.request("DELETE", `/v1/tokens/${tokenId}`);
+    }
+    /**
+     * Revoke an API token. Revoked tokens are invalidated immediately but remain
+     * visible in listings (with `revoked=true`).
+     */
+    async revokeToken(tokenId) {
+        await this.request("POST", `/v1/tokens/${tokenId}/revoke`);
+    }
     // Batch operations
     async batchMemories(operations) {
         return this.request("POST", "/v1/memories/batch", { operations });
@@ -362,20 +734,11 @@ export class MemoryLayerClient {
         const query = params.toString() ? `?${params.toString()}` : '';
         // Fetch NDJSON response
         const url = `${this.baseUrl}/v1/workspaces/${id}/export${query}`;
-        const headers = {};
-        if (this.apiKey) {
-            headers["Authorization"] = `Bearer ${this.apiKey}`;
-        }
-        if (this.sessionId) {
-            headers["X-Session-ID"] = this.sessionId;
-        }
-        if (this.workspaceId) {
-            headers["X-Workspace-ID"] = this.workspaceId;
-        }
+        const headers = this.buildHeaders(undefined, false);
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         try {
-            const response = await fetch(url, {
+            const response = await this.fetchImpl(url, {
                 method: "GET",
                 headers,
                 signal: controller.signal,
@@ -435,20 +798,11 @@ export class MemoryLayerClient {
         }
         const query = params.toString() ? `?${params.toString()}` : '';
         const url = `${this.baseUrl}/v1/workspaces/${id}/export${query}`;
-        const headers = {};
-        if (this.apiKey) {
-            headers["Authorization"] = `Bearer ${this.apiKey}`;
-        }
-        if (this.sessionId) {
-            headers["X-Session-ID"] = this.sessionId;
-        }
-        if (this.workspaceId) {
-            headers["X-Workspace-ID"] = this.workspaceId;
-        }
+        const headers = this.buildHeaders(undefined, false);
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         try {
-            const response = await fetch(url, {
+            const response = await this.fetchImpl(url, {
                 method: "GET",
                 headers,
                 signal: controller.signal,
@@ -475,22 +829,12 @@ export class MemoryLayerClient {
     }
     async importWorkspaceStream(workspaceId, ndjsonBody) {
         const url = `${this.baseUrl}/v1/workspaces/${workspaceId}/import`;
-        const headers = {
-            "Content-Type": "application/x-ndjson",
-        };
-        if (this.apiKey) {
-            headers["Authorization"] = `Bearer ${this.apiKey}`;
-        }
-        if (this.sessionId) {
-            headers["X-Session-ID"] = this.sessionId;
-        }
-        if (this.workspaceId) {
-            headers["X-Workspace-ID"] = this.workspaceId;
-        }
+        const headers = this.buildHeaders(undefined, false);
+        headers["Content-Type"] = "application/x-ndjson";
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         try {
-            const response = await fetch(url, {
+            const response = await this.fetchImpl(url, {
                 method: "POST",
                 headers,
                 body: ndjsonBody,
@@ -577,5 +921,490 @@ export class MemoryLayerClient {
     async contextCheckpoint() {
         await this.request("POST", "/v1/context/checkpoint");
     }
+    // ------------------------------------------------------------------ //
+    // Document operations (Enterprise)
+    // ------------------------------------------------------------------ //
+    /**
+     * Upload a document for ingestion.
+     *
+     * Requires MemoryLayer Enterprise. On OSS servers this throws
+     * `EnterpriseRequiredError`.
+     */
+    async uploadDocument(file, filename, options = {}) {
+        const formData = new FormData();
+        formData.append("file", file, filename);
+        if (options.targetContextId)
+            formData.append("target_context_id", options.targetContextId);
+        if (options.chunkingStrategy)
+            formData.append("chunking_strategy", options.chunkingStrategy);
+        if (options.chunkSize !== undefined)
+            formData.append("chunk_size", String(options.chunkSize));
+        if (options.chunkOverlap !== undefined)
+            formData.append("chunk_overlap", String(options.chunkOverlap));
+        if (options.importance !== undefined)
+            formData.append("importance", String(options.importance));
+        if (options.retainOriginal !== undefined)
+            formData.append("retain_original", String(options.retainOriginal));
+        const headers = this.buildHeaders(undefined, false);
+        const url = `${this.baseUrl}/v1/documents`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await this.fetchImpl(url, {
+                method: "POST",
+                headers,
+                body: formData,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                await this.handleError(response, "Document ingestion");
+            }
+            return await response.json();
+        }
+        catch (error) {
+            if (error instanceof MemoryLayerError)
+                throw error;
+            throw new MemoryLayerError(`Document upload failed: ${error}`);
+        }
+    }
+    /**
+     * List documents in the workspace.
+     */
+    async listDocuments(options) {
+        const params = new URLSearchParams();
+        if (options?.status)
+            params.set("status", options.status);
+        if (options?.limit !== undefined)
+            params.set("limit", String(options.limit));
+        if (options?.offset !== undefined)
+            params.set("offset", String(options.offset));
+        const query = params.toString();
+        return this.request("GET", `/v1/documents${query ? `?${query}` : ""}`, undefined, "Document management");
+    }
+    /**
+     * Get document metadata and processing status.
+     */
+    async getDocument(documentId) {
+        const response = await this.request("GET", `/v1/documents/${documentId}`, undefined, "Document management");
+        return response;
+    }
+    /**
+     * Delete a document and optionally its extracted memories.
+     */
+    async deleteDocument(documentId, deleteMemories = false) {
+        await this.request("DELETE", `/v1/documents/${documentId}?delete_memories=${deleteMemories}`, undefined, "Document management");
+    }
+    /**
+     * Search document pages using ColPali MaxSim visual similarity.
+     *
+     * Requires MemoryLayer Enterprise.
+     */
+    async searchDocumentPages(query, options = {}) {
+        const body = {
+            query,
+            limit: options.limit ?? 10,
+            doc_ids: options.docIds,
+        };
+        return this.request("POST", "/v1/documents/search", body, "Document page search");
+    }
+    /**
+     * Get all pages for a document.
+     */
+    async getDocumentPages(documentId) {
+        return this.request("GET", `/v1/documents/${documentId}/pages`, undefined, "Document pages");
+    }
+    /**
+     * Get a page image as a Blob.
+     */
+    async getPageImage(documentId, pageId) {
+        const headers = this.buildHeaders(undefined, false);
+        const url = `${this.baseUrl}/v1/documents/${documentId}/pages/${pageId}/image`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await this.fetchImpl(url, { method: "GET", headers, signal: controller.signal });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                await this.handleError(response, "Document page images");
+            }
+            return await response.blob();
+        }
+        catch (error) {
+            if (error instanceof MemoryLayerError)
+                throw error;
+            throw new MemoryLayerError(`Page image request failed: ${error}`);
+        }
+    }
+    /**
+     * Get ingestion job status.
+     */
+    async getJob(jobId) {
+        return this.request("GET", `/v1/documents/jobs/${jobId}`, undefined, "Document ingestion jobs");
+    }
+    /**
+     * List ingestion jobs in the workspace.
+     */
+    async listJobs(options) {
+        const params = new URLSearchParams();
+        if (options?.status)
+            params.set("status", options.status);
+        if (options?.limit !== undefined)
+            params.set("limit", String(options.limit));
+        const query = params.toString();
+        return this.request("GET", `/v1/documents/jobs${query ? `?${query}` : ""}`, undefined, "Document ingestion jobs");
+    }
+    /**
+     * Cancel a running ingestion job.
+     */
+    async cancelJob(jobId) {
+        await this.request("POST", `/v1/documents/jobs/${jobId}/cancel`, undefined, "Document ingestion jobs");
+    }
+    /**
+     * Reprocess a document with optionally different extraction options.
+     */
+    async reprocessDocument(documentId, options) {
+        const body = {};
+        if (options?.targetContextId)
+            body.target_context_id = options.targetContextId;
+        if (options?.chunkingStrategy)
+            body.chunking_strategy = options.chunkingStrategy;
+        if (options?.chunkSize !== undefined)
+            body.chunk_size = options.chunkSize;
+        if (options?.chunkOverlap !== undefined)
+            body.chunk_overlap = options.chunkOverlap;
+        if (options?.importance !== undefined)
+            body.importance = options.importance;
+        return this.request("POST", `/v1/documents/${documentId}/reprocess`, Object.keys(body).length ? body : undefined, "Document reprocessing");
+    }
+    // ------------------------------------------------------------------ //
+    // Chat History operations
+    // ------------------------------------------------------------------ //
+    async createThread(options = {}) {
+        const body = {
+            thread_id: options.threadId,
+            workspace_id: options.workspaceId ?? this.workspaceId,
+            user_id: options.userId,
+            context_id: options.contextId,
+            observer_id: options.observerId,
+            subject_id: options.subjectId,
+            title: options.title,
+            metadata: options.metadata,
+            expires_at: options.expiresAt,
+        };
+        const response = await this.request("POST", "/v1/threads", body);
+        return response.thread;
+    }
+    async listThreads(options = {}) {
+        const params = new URLSearchParams();
+        const wsId = options.workspaceId ?? this.workspaceId;
+        if (wsId)
+            params.set("workspace_id", wsId);
+        if (options.userId)
+            params.set("user_id", options.userId);
+        if (options.limit !== undefined)
+            params.set("limit", String(options.limit));
+        if (options.offset !== undefined)
+            params.set("offset", String(options.offset));
+        const query = params.toString();
+        const response = await this.request("GET", `/v1/threads${query ? `?${query}` : ""}`);
+        return response.threads;
+    }
+    async getThread(threadId, workspaceId) {
+        const params = new URLSearchParams();
+        const wsId = workspaceId ?? this.workspaceId;
+        if (wsId)
+            params.set("workspace_id", wsId);
+        const query = params.toString();
+        const response = await this.request("GET", `/v1/threads/${threadId}${query ? `?${query}` : ""}`);
+        return response.thread;
+    }
+    async getThreadFull(threadId, options) {
+        const params = new URLSearchParams();
+        const wsId = options?.workspaceId ?? this.workspaceId;
+        if (wsId)
+            params.set("workspace_id", wsId);
+        if (options?.limit !== undefined)
+            params.set("limit", String(options.limit));
+        if (options?.offset !== undefined)
+            params.set("offset", String(options.offset));
+        if (options?.order)
+            params.set("order", options.order);
+        const query = params.toString();
+        return this.request("GET", `/v1/threads/${threadId}/full${query ? `?${query}` : ""}`);
+    }
+    async deleteThread(threadId, workspaceId) {
+        const params = new URLSearchParams();
+        const wsId = workspaceId ?? this.workspaceId;
+        if (wsId)
+            params.set("workspace_id", wsId);
+        const query = params.toString();
+        await this.request("DELETE", `/v1/threads/${threadId}${query ? `?${query}` : ""}`);
+    }
+    /**
+     * List chat threads owned by a user across all workspaces.
+     *
+     * Unlike {@link listThreads}, this is keyed on (tenant, user, ownership) and
+     * does NOT require a workspace filter — used for user-session-scoped views.
+     */
+    async listUserThreads(userId, options = {}) {
+        const params = new URLSearchParams();
+        if (options.ownership)
+            params.set("ownership", options.ownership);
+        if (options.scopeFilter)
+            params.set("scope_filter", options.scopeFilter);
+        if (options.limit !== undefined)
+            params.set("limit", String(options.limit));
+        if (options.offset !== undefined)
+            params.set("offset", String(options.offset));
+        const query = params.toString();
+        const response = await this.request("GET", `/v1/threads/user/${userId}${query ? `?${query}` : ""}`);
+        return response.threads;
+    }
+    /** Update a thread (e.g. rename or change metadata). */
+    async updateThread(threadId, updates) {
+        const params = new URLSearchParams();
+        const wsId = updates.workspaceId ?? this.workspaceId;
+        if (wsId)
+            params.set("workspace_id", wsId);
+        const query = params.toString();
+        const body = {};
+        if (updates.title !== undefined)
+            body.title = updates.title;
+        if (updates.metadata !== undefined)
+            body.metadata = updates.metadata;
+        const response = await this.request("PUT", `/v1/threads/${threadId}${query ? `?${query}` : ""}`, body);
+        return response.thread;
+    }
+    /** Delete a single message from a thread. */
+    async deleteMessage(threadId, messageId, workspaceId) {
+        const params = new URLSearchParams();
+        const wsId = workspaceId ?? this.workspaceId;
+        if (wsId)
+            params.set("workspace_id", wsId);
+        const query = params.toString();
+        await this.request("DELETE", `/v1/threads/${threadId}/messages/${messageId}${query ? `?${query}` : ""}`);
+    }
+    async appendMessages(threadId, messages, workspaceId) {
+        const params = new URLSearchParams();
+        const wsId = workspaceId ?? this.workspaceId;
+        if (wsId)
+            params.set("workspace_id", wsId);
+        const query = params.toString();
+        return this.request("POST", `/v1/threads/${threadId}/messages${query ? `?${query}` : ""}`, { messages });
+    }
+    async getMessages(threadId, options) {
+        const params = new URLSearchParams();
+        const wsId = options?.workspaceId ?? this.workspaceId;
+        if (wsId)
+            params.set("workspace_id", wsId);
+        if (options?.limit !== undefined)
+            params.set("limit", String(options.limit));
+        if (options?.offset !== undefined)
+            params.set("offset", String(options.offset));
+        if (options?.afterIndex !== undefined)
+            params.set("after_index", String(options.afterIndex));
+        if (options?.order)
+            params.set("order", options.order);
+        const query = params.toString();
+        return this.request("GET", `/v1/threads/${threadId}/messages${query ? `?${query}` : ""}`);
+    }
+    async decomposeThread(threadId, workspaceId) {
+        const params = new URLSearchParams();
+        const wsId = workspaceId ?? this.workspaceId;
+        if (wsId)
+            params.set("workspace_id", wsId);
+        const query = params.toString();
+        return this.request("POST", `/v1/threads/${threadId}/decompose${query ? `?${query}` : ""}`);
+    }
+    // ------------------------------------------------------------------ //
+    // Dataset operations (Enterprise)
+    // ------------------------------------------------------------------ //
+    /**
+     * Upload a dataset for profiling and memory extraction.
+     *
+     * Requires MemoryLayer Enterprise. On OSS servers this throws
+     * `EnterpriseRequiredError`.
+     */
+    async uploadDataset(file, filename, options = {}) {
+        const formData = new FormData();
+        formData.append("file", file, filename);
+        if (options.name)
+            formData.append("name", options.name);
+        if (options.targetContextId)
+            formData.append("target_context_id", options.targetContextId);
+        if (options.importance !== undefined)
+            formData.append("importance", String(options.importance));
+        if (options.sampleRows !== undefined)
+            formData.append("sample_rows", String(options.sampleRows));
+        if (options.detectTimeSeries !== undefined)
+            formData.append("detect_time_series", String(options.detectTimeSeries));
+        if (options.generateSummaries !== undefined)
+            formData.append("generate_summaries", String(options.generateSummaries));
+        const headers = this.buildHeaders(undefined, false);
+        const url = `${this.baseUrl}/v1/datasets`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await this.fetchImpl(url, {
+                method: "POST",
+                headers,
+                body: formData,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                await this.handleError(response, "Dataset management");
+            }
+            return await response.json();
+        }
+        catch (error) {
+            if (error instanceof MemoryLayerError)
+                throw error;
+            throw new MemoryLayerError(`Dataset upload failed: ${error}`);
+        }
+    }
+    /**
+     * List datasets in the workspace.
+     */
+    async listDatasets(options) {
+        const params = new URLSearchParams();
+        if (options?.status)
+            params.set("status", options.status);
+        if (options?.limit !== undefined)
+            params.set("limit", String(options.limit));
+        if (options?.offset !== undefined)
+            params.set("offset", String(options.offset));
+        const query = params.toString();
+        return this.request("GET", `/v1/datasets${query ? `?${query}` : ""}`, undefined, "Dataset management");
+    }
+    /**
+     * Get dataset metadata, schema, and profile.
+     */
+    async getDataset(datasetId) {
+        return this.request("GET", `/v1/datasets/${datasetId}`, undefined, "Dataset management");
+    }
+    /**
+     * Delete a dataset and optionally its extracted memories.
+     */
+    async deleteDataset(datasetId, deleteMemories = false) {
+        await this.request("DELETE", `/v1/datasets/${datasetId}?delete_memories=${deleteMemories}`, undefined, "Dataset management");
+    }
+    /**
+     * Get memories extracted from a dataset.
+     */
+    async getDatasetMemories(datasetId) {
+        return this.request("GET", `/v1/datasets/${datasetId}/memories`, undefined, "Dataset management");
+    }
+    /**
+     * Query a slice of dataset data using DuckDB.
+     *
+     * Supports both structured filters and raw SQL (SELECT only).
+     * The dataset is queried as a table named 'data'.
+     */
+    async queryDatasetSlice(datasetId, options = {}) {
+        const body = {
+            limit: options.limit ?? 100,
+            offset: options.offset ?? 0,
+            descending: options.descending ?? false,
+        };
+        if (options.sql !== undefined)
+            body.sql = options.sql;
+        if (options.columns !== undefined)
+            body.columns = options.columns;
+        if (options.filters !== undefined)
+            body.filters = options.filters;
+        if (options.orderBy !== undefined)
+            body.order_by = options.orderBy;
+        return this.request("POST", `/v1/datasets/${datasetId}/slice`, body, "Dataset management");
+    }
+    /**
+     * Get dataset processing job status.
+     */
+    async getDatasetJob(jobId) {
+        return this.request("GET", `/v1/datasets/jobs/${jobId}`, undefined, "Dataset processing jobs");
+    }
+    /**
+     * List dataset processing jobs in the workspace.
+     */
+    async listDatasetJobs(options) {
+        const params = new URLSearchParams();
+        if (options?.status)
+            params.set("status", options.status);
+        if (options?.limit !== undefined)
+            params.set("limit", String(options.limit));
+        const query = params.toString();
+        return this.request("GET", `/v1/datasets/jobs${query ? `?${query}` : ""}`, undefined, "Dataset processing jobs");
+    }
+    /**
+     * Cancel a running dataset processing job.
+     */
+    async cancelDatasetJob(jobId) {
+        await this.request("POST", `/v1/datasets/jobs/${jobId}/cancel`, undefined, "Dataset processing jobs");
+    }
+    /** Used internally by SkillsNamespace to make requests with OBO authority. */
+    async _skillsRequest(method, path, body, authority, responseMode = "json") {
+        return this.request(method, path, body, undefined, authority, responseMode);
+    }
+    /** Used internally by McpServersNamespace to make requests with OBO authority. */
+    async _mcpServersRequest(method, path, body, authority) {
+        return this.request(method, path, body, undefined, authority);
+    }
+    /** Used internally by KnowledgebaseNamespace to make requests with OBO authority. */
+    async _kbRequest(method, path, body, authority, responseMode = "json") {
+        return this.request(method, path, body, undefined, authority, responseMode);
+    }
+    /** Used internally by RpgNamespace to make requests with OBO authority. */
+    async _rpgRequest(method, path, body, authority) {
+        return this.request(method, path, body, undefined, authority);
+    }
+}
+/**
+ * Lightweight OBO proxy returned by `client.actingFor()`.
+ * Delegates all calls to the parent client with a fixed AuthorityContext and
+ * optional workspace override. Per-call authority headers are computed fresh
+ * on each request — no shared mutable state, so concurrent calls for different
+ * subjects on the same underlying client never interfere.
+ */
+export class OboProxy {
+    _client;
+    _authority;
+    _workspaceId;
+    /** Skills namespace scoped to this proxy's authority. */
+    skills;
+    /** MCP Servers namespace scoped to this proxy's authority. */
+    mcpServers;
+    constructor(client, authority, workspaceId) {
+        this._client = client;
+        this._authority = authority;
+        this._workspaceId = workspaceId;
+        this.skills = new SkillsNamespace(client, authority, workspaceId);
+        this.mcpServers = new McpServersNamespace(client, authority, workspaceId);
+    }
+    /** Further scope this proxy to a single workspace. */
+    forWorkspace(workspaceId) {
+        return new OboProxy(this._client, this._authority, workspaceId);
+    }
+    async remember(content, options = {}) {
+        return this._client.remember(content, {
+            ...options,
+            workspaceId: options.workspaceId ?? this._workspaceId,
+            authority: options.authority ?? this._authority,
+        });
+    }
+    async recall(query, options = {}) {
+        return this._client.recall(query, {
+            ...options,
+            workspaceId: options.workspaceId ?? this._workspaceId,
+            authority: options.authority ?? this._authority,
+        });
+    }
+    async reflect(query, options = {}) {
+        return this._client.reflect(query, {
+            ...options,
+            workspaceId: options.workspaceId ?? this._workspaceId,
+            authority: options.authority ?? this._authority,
+        });
+    }
 }
 //# sourceMappingURL=client.js.map