@rool-dev/sdk 0.11.8 → 0.11.9-dev.38b242c

package/dist/space-session.js

@@ -26,7 +26,7 @@ function walkBranch(interactions, leafId) {
 }
 /** Find the default leaf: the most recent interaction by timestamp that has no children. */
 function findDefaultLeaf(interactions) {
-    if (!interactions || Array.isArray(interactions))
+    if (!interactions)
         return undefined;
     const childSet = new Set();
     for (const ix of Object.values(interactions)) {
@@ -156,13 +156,20 @@ function base64Body(data) {
     return bytes.buffer;
 }
 /**
- * Operational handle for a space.
+ * A thin handle over a space's raw APIs (GraphQL, WebDAV, REST) plus the
+ * conversation roster the server pushes over SSE. It holds no schema, metadata,
+ * or conversation *content* state — schema and meta live in the filesystem
+ * (`/space/<collection>/.schema.json`, `/space/.meta.json`) and are read on
+ * demand via {@link readSchema} / {@link readMeta}; conversation contents live
+ * on {@link ConversationHandle} objects acquired on demand via
+ * {@link conversation}. The lightweight conversation meta list (ids + names +
+ * counts) is maintained here from openSpace + SSE. Reactive consumers (e.g. the
+ * Svelte wrapper) own any cached presentation of that state; this class just
+ * wraps the wire.
  *
- * Objects are addressed by machine path (`/space/.../*.json`). Conversation handles
- * control attribution and AI history. Only schema, metadata,
- * object stats, and conversation history are cached locally. Object bodies are
- * fetched on demand. Object/file reactivity is exposed at the space level via
- * WebDAV sync notifications.
+ * Objects are addressed by machine path (`/space/.../*.json`). Conversation
+ * handles carry attribution headers for WebDAV writes. Object/file reactivity
+ * is exposed via `filesChanged` / `filesReset` plus WebDAV `syncCollection()`.
  */
 export class SpaceOperations extends EventEmitter {
     _id;
@@ -175,13 +182,9 @@ export class SpaceOperations extends EventEmitter {
     _webdav;
     _onCloseCallback;
     _logger;
-    // Local cache for bounded data (schema, metadata, conversations, object stats)
-    _meta;
-    _schema;
-    _conversations;
-    _objectStats;
-    // Active leaf per conversation (client-side tree cursor)
-    _activeLeaves = new Map();
+    // Conversation roster — lightweight meta, no interaction bodies. Maintained
+    // from openSpace + SSE conversation_updated events.
+    _conversationMeta;
     constructor(config) {
         super();
         this._id = config.id;
@@ -194,11 +197,7 @@ export class SpaceOperations extends EventEmitter {
         this._webdav = config.webdav;
         this._logger = config.logger;
         this._onCloseCallback = config.onClose;
-        // Initialize local cache from server data
-        this._meta = config.meta;
-        this._schema = config.schema;
-        this._conversations = config.conversations;
-        this._objectStats = new Map(Object.entries(config.objectStats));
+        this._conversationMeta = config.conversationMeta;
     }
     /**
      * Handle an event from the shared space subscription.
@@ -208,21 +207,6 @@ export class SpaceOperations extends EventEmitter {
     _handleEvent(event) {
         this.applySpaceContentEvent(event);
     }
-    /**
-     * Apply resync data after reconnection. Called by the client, which
-     * fetches space data once and applies it.
-     * @internal
-     */
-    _applyResyncData(data) {
-        if (this._closed)
-            return;
-        this._meta = data.meta;
-        this._schema = data.schema;
-        this._objectStats = new Map(Object.entries(data.objectStats));
-        this._conversations = data.conversations;
-        this._activeLeaves.clear();
-        this.emit('reset', { source: 'system' });
-    }
     get id() {
         return this._id;
     }
@@ -239,77 +223,34 @@ export class SpaceOperations extends EventEmitter {
     get isReadOnly() {
         return this._role === 'viewer';
     }
-    /** @internal */
-    _getInteractionsImpl(conversationId) {
-        const interactions = this._conversations[conversationId]?.interactions;
-        if (!interactions)
-            return [];
-        // Handle legacy array format
-        if (Array.isArray(interactions))
-            return interactions;
-        const leafId = this._getActiveLeafImpl(conversationId);
-        if (!leafId)
-            return [];
-        return walkBranch(interactions, leafId);
-    }
-    /** @internal */
-    _getTreeImpl(conversationId) {
-        const interactions = this._conversations[conversationId]?.interactions;
-        if (!interactions || Array.isArray(interactions))
-            return {};
-        return interactions;
-    }
-    /** @internal */
-    _getActiveLeafImpl(conversationId) {
-        return this._activeLeaves.get(conversationId) ?? findDefaultLeaf(this._conversations[conversationId]?.interactions);
-    }
-    /** @internal */
-    _setActiveLeafImpl(interactionId, conversationId) {
-        const interactions = this._conversations[conversationId]?.interactions;
-        if (!interactions || Array.isArray(interactions) || !interactions[interactionId]) {
-            throw new Error(`Interaction "${interactionId}" not found in conversation "${conversationId}"`);
-        }
-        this._activeLeaves.set(conversationId, interactionId);
-        this.emit('conversationUpdated', {
-            conversationId,
-            source: 'local_user',
-        });
-    }
     /**
-     * Get all conversations in this space.
-     * Returns summary info (no full interaction data) for each conversation.
+     * Lightweight conversation roster (no interaction bodies). Maintained from
+     * openSpace + SSE; reactive consumers mirror this list.
      */
     getConversations() {
-        return Object.entries(this._conversations).map(([id, conv]) => ({
-            id,
-            name: conv.name ?? null,
-            systemInstruction: conv.systemInstruction ?? null,
-            createdAt: conv.createdAt,
-            createdBy: conv.createdBy,
-            interactionCount: conv.interactions ? Object.keys(conv.interactions).length : 0,
-        }));
+        return this._conversationMeta;
     }
     /**
-     * Delete a conversation from this space.
+     * Delete a conversation. The server confirms via SSE (`conversation_updated`
+     * with a null conversation), which updates the roster and any live handle.
      */
     async deleteConversation(conversationId) {
         await this._graphqlClient.deleteConversation(this._id, conversationId);
-        // Optimistic local update — remove from cache and emit event
-        // in case the server doesn't send a conversation_updated event for deletes
-        if (this._conversations[conversationId]) {
-            delete this._conversations[conversationId];
-            this.emit('conversationUpdated', {
-                conversationId,
-                source: 'local_user',
-            });
-        }
     }
     /**
-     * Get a handle for a specific conversation.
+     * Get a handle for a conversation. The handle holds its own interaction tree
+     * + cursor; call {@link ConversationHandle.load} to fetch an existing
+     * conversation's contents, or just {@link ConversationHandle.prompt} to start
+     * a new one (SSE fills the tree). Consumers feed SSE updates into the handle
+     * via {@link ConversationHandle.applyUpdate}.
      */
     conversation(conversationId) {
         return new ConversationHandle(this, conversationId);
     }
+    /** @internal — fetch a conversation's full contents from the server. */
+    async _fetchConversationImpl(conversationId) {
+        return this._graphqlClient.getConversation(this._id, conversationId);
+    }
     /**
      * Close this space session and clean up resources.
      */
@@ -351,10 +292,8 @@ export class SpaceOperations extends EventEmitter {
     async clearHistory() {
         this._logger.warn('[RoolSpace] clearHistory() is a no-op: checkpoint history is now managed by the server.');
     }
-    davHeaders(conversationId, interactionId) {
-        const headers = new Headers({
-            'X-Rool-Conversation-Id': conversationId,
-        });
+    davHeaders(interactionId) {
+        const headers = new Headers();
         if (interactionId)
             headers.set('X-Rool-Interaction-Id', interactionId);
         return headers;
@@ -398,19 +337,15 @@ export class SpaceOperations extends EventEmitter {
         }
         return result;
     }
-    /** Get an object's cached audit information. */
-    stat(path) {
-        return this._objectStats.get(objectPath(path));
-    }
-    /** @internal */
-    async _putObjectImpl(path, body, conversationId) {
+    /** Create or replace an object JSON file. */
+    async putObject(path, body) {
         const canonical = objectPath(path);
         const optimistic = objectFromBody(canonical, body);
         try {
             const interactionId = generateEntityId();
             await this._webdav.put(canonical, JSON.stringify(body), {
                 contentType: 'application/json',
-                headers: this.davHeaders(conversationId, interactionId),
+                headers: this.davHeaders(interactionId),
             });
             const fresh = await this.getObject(canonical) ?? optimistic;
             return { object: fresh, message: `Put ${canonical}` };
@@ -421,8 +356,8 @@ export class SpaceOperations extends EventEmitter {
             throw error;
         }
     }
-    /** @internal */
-    async _patchObjectImpl(path, options, conversationId) {
+    /** Patch an existing object JSON file. */
+    async patchObject(path, options) {
         const canonical = objectPath(path);
         const data = options.data ?? {};
         const current = await this.readObject(canonical);
@@ -435,7 +370,7 @@ export class SpaceOperations extends EventEmitter {
             await this._webdav.put(canonical, JSON.stringify(body), {
                 contentType: 'application/json',
                 ifMatch: current.etag ?? undefined,
-                headers: this.davHeaders(conversationId, interactionId),
+                headers: this.davHeaders(interactionId),
             });
             const fresh = await this.getObject(canonical) ?? optimistic;
             return { object: fresh, message: `Patched ${canonical}` };
@@ -446,23 +381,22 @@ export class SpaceOperations extends EventEmitter {
             throw error;
         }
     }
-    /** @internal */
-    async _moveObjectImpl(from, to, options, conversationId) {
+    /** Move (rename/relocate) an object. */
+    async moveObject(from, to, options) {
         const fromPath = objectPath(from);
         const toPath = objectPath(to);
         const optimistic = objectFromBody(toPath, options?.body ?? {});
         try {
             const interactionId = generateEntityId();
             await this._webdav.move(fromPath, toPath, {
-                headers: this.davHeaders(conversationId, interactionId),
+                headers: this.davHeaders(interactionId),
             });
             if (options?.body) {
                 await this._webdav.put(toPath, JSON.stringify(options.body), {
                     contentType: 'application/json',
-                    headers: this.davHeaders(conversationId, interactionId),
+                    headers: this.davHeaders(interactionId),
                 });
             }
-            this._objectStats.delete(fromPath);
             const fresh = await this.getObject(toPath) ?? optimistic;
             return { object: fresh, message: `Moved ${fromPath} to ${toPath}` };
         }
@@ -472,8 +406,8 @@ export class SpaceOperations extends EventEmitter {
             throw error;
         }
     }
-    /** @internal */
-    async _deleteObjectsImpl(paths, conversationId) {
+    /** Delete object JSON files by path. */
+    async deleteObjects(paths) {
         if (paths.length === 0)
             return;
         const canonical = paths.map(objectPath);
@@ -481,9 +415,8 @@ export class SpaceOperations extends EventEmitter {
             const interactionId = generateEntityId();
             for (const path of canonical) {
                 await this._webdav.delete(path, {
-                    headers: this.davHeaders(conversationId, interactionId),
+                    headers: this.davHeaders(interactionId),
                 });
-                this._objectStats.delete(path);
             }
         }
         catch (error) {
@@ -492,158 +425,95 @@ export class SpaceOperations extends EventEmitter {
             throw error;
         }
     }
-    /** Get the current schema for this space. */
-    getSchema() {
-        return this._schema;
-    }
-    /** @internal */
-    async _createCollectionImpl(name, fields, options, conversationId) {
-        if (this._schema[name]) {
-            throw new Error(`Collection "${name}" already exists`);
-        }
-        // Optimistic local update
-        const optimisticDef = collectionDef(fields, options);
-        this._schema[name] = optimisticDef;
-        try {
-            await this._webdav.mkcol(collectionPath(name), { headers: this.davHeaders(conversationId, generateEntityId()) });
-            await this._webdav.put(schemaPath(name), JSON.stringify(optimisticDef), {
-                contentType: 'application/json',
-                headers: this.davHeaders(conversationId, generateEntityId()),
-            });
-            this.emit('schemaUpdated', { schema: this._schema, source: 'local_user' });
-            return optimisticDef;
-        }
-        catch (error) {
-            this._logger.error('[RoolSpace] Failed to create collection:', error);
-            delete this._schema[name];
-            throw error;
-        }
-    }
-    /** @internal */
-    async _alterCollectionImpl(name, fields, options, conversationId) {
-        if (!this._schema[name]) {
-            throw new Error(`Collection "${name}" not found`);
-        }
-        const previous = this._schema[name];
-        this._schema[name] = collectionDef(fields, options);
-        try {
-            const updated = this._schema[name];
-            await this._webdav.put(schemaPath(name), JSON.stringify(updated), {
-                contentType: 'application/json',
-                headers: this.davHeaders(conversationId, generateEntityId()),
-            });
-            this.emit('schemaUpdated', { schema: this._schema, source: 'local_user' });
-            return updated;
-        }
-        catch (error) {
-            this._logger.error('[RoolSpace] Failed to alter collection:', error);
-            this._schema[name] = previous;
-            throw error;
-        }
-    }
-    /** @internal */
-    async _dropCollectionImpl(name, conversationId) {
-        if (!this._schema[name]) {
-            throw new Error(`Collection "${name}" not found`);
-        }
-        const previous = this._schema[name];
-        delete this._schema[name];
+    /**
+     * Read space metadata from `/space/.meta.json`. Returns `{}` when the space has
+     * no metadata file yet. Stateless — callers (e.g. a reactive wrapper) cache and
+     * re-fetch this on their own schedule, typically when a file-tree sync reports
+     * the node changed.
+     */
+    async readMeta() {
         try {
-            await this._webdav.delete(collectionPath(name), { collection: true, headers: this.davHeaders(conversationId, generateEntityId()) });
-            this.emit('schemaUpdated', { schema: this._schema, source: 'local_user' });
+            const response = await this._webdav.get('/space/.meta.json');
+            return jsonObject(await response.json(), 'space meta');
         }
         catch (error) {
-            this._logger.error('[RoolSpace] Failed to drop collection:', error);
-            this._schema[name] = previous;
+            if (error instanceof WebDAVError && error.status === 404)
+                return {};
             throw error;
         }
     }
-    /** @internal */
-    _getSystemInstructionImpl(conversationId) {
-        return this._conversations[conversationId]?.systemInstruction;
-    }
-    /** @internal */
-    async _setSystemInstructionImpl(instruction, conversationId) {
-        this._ensureConversationImpl(conversationId);
-        const conv = this._conversations[conversationId];
-        const previousInstruction = conv.systemInstruction;
-        if (instruction === null) {
-            delete conv.systemInstruction;
-        }
-        else {
-            conv.systemInstruction = instruction;
-        }
-        this.emit('conversationUpdated', {
-            conversationId,
-            source: 'local_user',
+    /**
+     * Write the full metadata blob to `/space/.meta.json`, attributed to a
+     * conversation. Callers compose the blob (e.g. read-merge-write) — this does no
+     * merging.
+     */
+    async writeMeta(meta) {
+        await this._webdav.put('/space/.meta.json', JSON.stringify(meta), {
+            contentType: 'application/json',
+            headers: this.davHeaders(generateEntityId()),
         });
-        try {
-            await this._graphqlClient.updateConversation(this._id, conversationId, { systemInstruction: instruction });
-        }
-        catch (error) {
-            this._logger.error('[RoolSpace] Failed to set system instruction:', error);
-            if (previousInstruction === undefined) {
-                delete conv.systemInstruction;
+    }
+    /**
+     * Read the collection schema: one `/space/<name>/.schema.json` per collection
+     * directory under `/space`. Returns `{}` for a space with no collections.
+     * Stateless — reactive callers re-fetch when a `.schema.json` node changes.
+     */
+    async readSchema() {
+        const listing = await this._webdav.propfind('/space', { depth: '1', props: ['resourcetype'] });
+        const collections = listing.responses
+            .filter((r) => r.isCollection && r.path !== '/space')
+            .map((r) => r.path.split('/').pop());
+        const entries = await Promise.all(collections.map(async (name) => {
+            try {
+                const response = await this._webdav.get(`/space/${name}/.schema.json`);
+                return [name, jsonObject(await response.json(), `schema ${name}`)];
             }
-            else {
-                conv.systemInstruction = previousInstruction;
+            catch (error) {
+                if (error instanceof WebDAVError && error.status === 404)
+                    return null;
+                throw error;
             }
-            throw error;
-        }
+        }));
+        const schema = {};
+        for (const entry of entries)
+            if (entry)
+                schema[entry[0]] = entry[1];
+        return schema;
     }
-    /** @internal */
-    async _renameConversationImpl(name, conversationId) {
-        this._ensureConversationImpl(conversationId);
-        const conv = this._conversations[conversationId];
-        const previousName = conv.name;
-        conv.name = name;
-        this.emit('conversationUpdated', {
-            conversationId,
-            source: 'local_user',
+    /** Create a new collection (MKCOL + schema JSON). */
+    async createCollection(name, fields, options) {
+        const def = collectionDef(fields, options);
+        await this._webdav.mkcol(collectionPath(name), { headers: this.davHeaders(generateEntityId()) });
+        await this._webdav.put(schemaPath(name), JSON.stringify(def), {
+            contentType: 'application/json',
+            headers: this.davHeaders(generateEntityId()),
         });
-        try {
-            await this._graphqlClient.updateConversation(this._id, conversationId, { name });
-        }
-        catch (error) {
-            this._logger.error('[RoolSpace] Failed to rename conversation:', error);
-            conv.name = previousName;
-            throw error;
-        }
+        return def;
     }
-    /** @internal */
-    _ensureConversationImpl(conversationId) {
-        if (!this._conversations[conversationId]) {
-            this._conversations[conversationId] = {
-                createdAt: Date.now(),
-                createdBy: this._userId,
-                interactions: {},
-            };
-        }
-    }
-    /** @internal */
-    _setMetadataImpl(key, value, conversationId) {
-        this._meta[key] = value;
-        this.emit('metadataUpdated', { metadata: this._meta, source: 'local_user' });
-        // Fire-and-forget server call
-        this._graphqlClient.setSpaceMeta(this._id, this._meta, conversationId)
-            .catch((error) => {
-            this._logger.error('[RoolSpace] Failed to set meta:', error);
+    /** Alter an existing collection's schema JSON. */
+    async alterCollection(name, fields, options) {
+        const def = collectionDef(fields, options);
+        await this._webdav.put(schemaPath(name), JSON.stringify(def), {
+            contentType: 'application/json',
+            headers: this.davHeaders(generateEntityId()),
         });
+        return def;
     }
-    /** Get a space-level metadata value. */
-    getMetadata(key) {
-        return this._meta[key];
+    /** Drop a collection (DELETE). */
+    async dropCollection(name) {
+        await this._webdav.delete(collectionPath(name), { collection: true, headers: this.davHeaders(generateEntityId()) });
     }
-    /** Get all space-level metadata. */
-    getAllMetadata() {
-        return this._meta;
+    /** @internal */
+    async _setSystemInstructionImpl(instruction, conversationId) {
+        await this._graphqlClient.updateConversation(this._id, conversationId, { systemInstruction: instruction });
+    }
+    /** @internal */
+    async _renameConversationImpl(name, conversationId) {
+        await this._graphqlClient.updateConversation(this._id, conversationId, { name });
     }
     /** @internal */
     async _promptImpl(prompt, options, conversationId) {
-        const { attachments, parentInteractionId: explicitParent, signal, interactionId: providedId, ...rest } = options ?? {};
-        // Callers may supply the id so they can render an optimistic message keyed by
-        // the id the server will echo back (see PromptOptions.interactionId).
-        const interactionId = providedId ?? generateEntityId();
+        const { attachments, signal, interactionId = generateEntityId(), parentInteractionId = null, ...rest } = options ?? {};
         let attachmentRefs;
         if (attachments?.length) {
             attachmentRefs = await Promise.all(attachments.map(async (attachment) => {
@@ -651,12 +521,6 @@ export class SpaceOperations extends EventEmitter {
                 return machineUri(path);
             }));
         }
-        // Auto-continue from active leaf if no explicit parent provided
-        const parentInteractionId = explicitParent !== undefined
-            ? explicitParent
-            : (this._getActiveLeafImpl(conversationId) ?? null);
-        // Optimistically set active leaf before the server call.
-        this._activeLeaves.set(conversationId, interactionId);
         let onAbort;
         if (signal) {
             if (signal.aborted) {
@@ -691,6 +555,7 @@ export class SpaceOperations extends EventEmitter {
         return {
             message: result.message,
             objects,
+            creditsUsed: result.creditsUsed,
         };
     }
     /**
@@ -702,19 +567,6 @@ export class SpaceOperations extends EventEmitter {
     async stopInteraction(interactionId) {
         return this._graphqlClient.stopInteraction(this._id, interactionId);
     }
-    /** @internal */
-    async _stopImpl(conversationId) {
-        const leafId = this._getActiveLeafImpl(conversationId);
-        if (!leafId)
-            return false;
-        const interactions = this._conversations[conversationId]?.interactions;
-        const interaction = interactions && !Array.isArray(interactions) ? interactions[leafId] : undefined;
-        // Skip the round trip when we already know the interaction has settled.
-        if (interaction && (interaction.status === 'done' || interaction.status === 'error')) {
-            return false;
-        }
-        return this.stopInteraction(leafId);
-    }
     /**
      * Fetch an external URL via the server proxy, bypassing CORS restrictions.
      */
@@ -738,46 +590,59 @@ export class SpaceOperations extends EventEmitter {
     applySpaceContentEvent(event) {
         if (this._closed)
             return;
+        if (event.type !== 'conversation_updated' || !event.conversationId)
+            return;
         const changeSource = event.source === 'agent' ? 'remote_agent' : 'remote_user';
-        switch (event.type) {
-            case 'conversation_updated':
-                if (event.conversationId) {
-                    const prev = this._conversations[event.conversationId];
-                    if (event.conversation) {
-                        this._conversations[event.conversationId] = event.conversation;
-                    }
-                    else {
-                        delete this._conversations[event.conversationId];
-                    }
-                    if (JSON.stringify(prev) === JSON.stringify(event.conversation))
-                        break;
-                    if (event.conversation && !Array.isArray(event.conversation.interactions)) {
-                        const currentLeaf = this._getActiveLeafImpl(event.conversationId);
-                        if (currentLeaf) {
-                            for (const ix of Object.values(event.conversation.interactions)) {
-                                if (ix.parentId === currentLeaf && ix.id !== currentLeaf) {
-                                    this._activeLeaves.set(event.conversationId, ix.id);
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                    this.emit('conversationUpdated', {
-                        conversationId: event.conversationId,
-                        source: changeSource,
-                    });
-                }
-                break;
+        const conversation = event.conversation ?? null;
+        this._updateConversationMeta(event.conversationId, conversation);
+        this.emit('conversationUpdated', {
+            conversationId: event.conversationId,
+            conversation,
+            source: changeSource,
+        });
+    }
+    /** Maintain the conversation meta list from an SSE update. */
+    _updateConversationMeta(id, conversation) {
+        if (conversation === null) {
+            this._conversationMeta = this._conversationMeta.filter((m) => m.id !== id);
+            return;
+        }
+        const interactionCount = conversation.interactions ? Object.keys(conversation.interactions).length : 0;
+        const entry = {
+            id,
+            name: conversation.name ?? null,
+            systemInstruction: conversation.systemInstruction ?? null,
+            createdAt: conversation.createdAt,
+            createdBy: conversation.createdBy,
+            interactionCount,
+            updatedAt: Date.now(),
+        };
+        const idx = this._conversationMeta.findIndex((m) => m.id === id);
+        if (idx >= 0) {
+            this._conversationMeta = [
+                ...this._conversationMeta.slice(0, idx),
+                entry,
+                ...this._conversationMeta.slice(idx + 1),
+            ];
+        }
+        else {
+            this._conversationMeta = [entry, ...this._conversationMeta];
         }
     }
 }
 /**
- * A lightweight handle for a specific conversation.
+ * A stateful handle for a single conversation. Holds the interaction tree and a
+ * client-side branch cursor (active leaf). Acquired on demand via
+ * {@link SpaceOperations.conversation}; a fresh handle each call — the SDK
+ * holds no handle map. The handle starts unloaded; call {@link load} to fetch
+ * an existing conversation's contents, or just {@link prompt} to start a new
+ * one. Feed SSE updates via {@link applyUpdate}.
  */
 export class ConversationHandle {
-    /** @internal */
     _space;
     _conversationId;
+    _data = null;
+    _activeLeaf;
     /** @internal */
     constructor(space, conversationId) {
         this._space = space;
@@ -785,25 +650,75 @@ export class ConversationHandle {
     }
     /** The conversation ID this handle is scoped to. */
     get conversationId() { return this._conversationId; }
-    /** Get the active branch of this conversation as a flat array (root → leaf). */
+    /** Whether the conversation contents have been loaded. */
+    get loaded() { return this._data !== null; }
+    /** Fetch the full conversation from the server. Skips the overwrite if SSE
+     *  already filled the tree during the fetch (SSE is the real-time source of
+     *  truth). Pass `true` to force a reload — used after a reconnect `reset`,
+     *  where we may have missed SSE updates while disconnected. */
+    async load(force = false) {
+        const data = await this._space._fetchConversationImpl(this._conversationId);
+        if (!force && this._data)
+            return;
+        this._data = data;
+        this._activeLeaf = this._data ? findDefaultLeaf(this._data.interactions) : undefined;
+    }
+    /** Apply an SSE conversation update — updates the tree + cursor. Pass `null`
+     *  for a deletion. */
+    applyUpdate(conversation) {
+        if (conversation === null) {
+            this._data = null;
+            this._activeLeaf = undefined;
+            return;
+        }
+        // Advance the cursor to a new child of the current leaf, if one appeared.
+        const currentLeaf = this._activeLeaf;
+        if (currentLeaf) {
+            for (const ix of Object.values(conversation.interactions)) {
+                if (ix.parentId === currentLeaf && ix.id !== currentLeaf) {
+                    this._activeLeaf = ix.id;
+                    break;
+                }
+            }
+        }
+        this._data = conversation;
+        if (this._activeLeaf === undefined) {
+            this._activeLeaf = findDefaultLeaf(conversation.interactions);
+        }
+    }
+    /** Get the active branch as a flat array (root → leaf). Empty until loaded. */
     getInteractions() {
-        return this._space._getInteractionsImpl(this._conversationId);
+        if (!this._data)
+            return [];
+        const leaf = this._activeLeaf ?? findDefaultLeaf(this._data.interactions);
+        if (!leaf)
+            return [];
+        return walkBranch(this._data.interactions, leaf);
     }
-    /** Get the full interaction tree as a record. */
+    /** Get the full interaction tree as a record. Empty until loaded. */
     getTree() {
-        return this._space._getTreeImpl(this._conversationId);
+        if (!this._data)
+            return {};
+        return this._data.interactions;
     }
     /** Get the active leaf interaction ID, or undefined if empty. */
     get activeLeafId() {
-        return this._space._getActiveLeafImpl(this._conversationId);
+        if (this._activeLeaf)
+            return this._activeLeaf;
+        if (!this._data)
+            return undefined;
+        return findDefaultLeaf(this._data.interactions);
     }
     /** Switch to a different branch by setting the active leaf. */
     setActiveLeaf(interactionId) {
-        this._space._setActiveLeafImpl(interactionId, this._conversationId);
+        if (!this._data || !this._data.interactions[interactionId]) {
+            throw new Error(`Interaction "${interactionId}" not found in conversation "${this._conversationId}"`);
+        }
+        this._activeLeaf = interactionId;
     }
     /** Get the system instruction for this conversation. */
     getSystemInstruction() {
-        return this._space._getSystemInstructionImpl(this._conversationId);
+        return this._data?.systemInstruction;
     }
     /** Set the system instruction for this conversation. Pass null to clear. */
     async setSystemInstruction(instruction) {
@@ -817,29 +732,16 @@ export class ConversationHandle {
     async delete() {
         return this._space.deleteConversation(this._conversationId);
     }
-    /** Create or replace an object JSON file. */
-    async putObject(path, body) {
-        return this._space._putObjectImpl(path, body, this._conversationId);
-    }
-    /** Patch an existing object JSON file. */
-    async patchObject(path, options) {
-        return this._space._patchObjectImpl(path, options, this._conversationId);
-    }
-    /** Move (rename/relocate) an object. */
-    async moveObject(from, to, options) {
-        return this._space._moveObjectImpl(from, to, options, this._conversationId);
-    }
-    /** Delete object JSON files by path. */
-    async deleteObjects(paths) {
-        return this._space._deleteObjectsImpl(paths, this._conversationId);
-    }
-    /** @deprecated Use deleteObjects instead. */
-    async deletePaths(paths) {
-        return this.deleteObjects(paths);
-    }
-    /** Send a prompt to the AI agent, scoped to this conversation's history. */
+    /** Send a prompt to the AI agent, scoped to this conversation's history.
+     *  Auto-continues from the active leaf unless `parentInteractionId` is set. */
     async prompt(text, options) {
-        return this._space._promptImpl(text, options, this._conversationId);
+        const interactionId = options?.interactionId ?? generateEntityId();
+        const parentInteractionId = options?.parentInteractionId !== undefined
+            ? options.parentInteractionId
+            : (this.activeLeafId ?? null);
+        // Optimistic: advance the cursor to the new interaction.
+        this._activeLeaf = interactionId;
+        return this._space._promptImpl(text, { ...options, interactionId, parentInteractionId }, this._conversationId);
     }
     /**
      * Stop this conversation's in-flight interaction, if any. No-op returning
@@ -847,22 +749,13 @@ export class ConversationHandle {
      * {@link RoolSpace.stopInteraction}.
      */
     async stop() {
-        return this._space._stopImpl(this._conversationId);
-    }
-    /** Create a new collection schema. */
-    async createCollection(name, fields, options) {
-        return this._space._createCollectionImpl(name, fields, options, this._conversationId);
-    }
-    /** Alter an existing collection schema. */
-    async alterCollection(name, fields, options) {
-        return this._space._alterCollectionImpl(name, fields, options, this._conversationId);
-    }
-    /** Drop a collection schema. */
-    async dropCollection(name) {
-        return this._space._dropCollectionImpl(name, this._conversationId);
-    }
-    setMetadata(key, value) {
-        return this._space._setMetadataImpl(key, value, this._conversationId);
+        const leafId = this.activeLeafId;
+        if (!leafId)
+            return false;
+        const interaction = this._data?.interactions[leafId];
+        if (interaction && (interaction.status === 'done' || interaction.status === 'error'))
+            return false;
+        return this._space.stopInteraction(leafId);
     }
 }
 //# sourceMappingURL=space-session.js.map