@sema-agent/core/dist/engine/session/memory-repo.js

Stateless, task-oriented AI agent core

import { SessionError } from "../harness/types.js";
import { validateEntriesForImport } from "./import-validate.js";
import { InMemorySessionStorage } from "./memory-storage.js";
import { createSessionId, createTimestamp, getEntriesToFork, toSession } from "./repo-utils.js";
export class InMemorySessionRepo {
    sessions = new Map();
    async create(options = {}) {
        if (options.id !== undefined) {
            const existing = this.sessions.get(options.id);
            if (existing)
                return existing;
        }
        const metadata = {
            id: options.id ?? createSessionId(),
            createdAt: createTimestamp(),
        };
        const storage = new InMemorySessionStorage({ metadata });
        const session = toSession(storage);
        this.sessions.set(metadata.id, session);
        return session;
    }
    async open(metadata) {
        const session = this.sessions.get(metadata.id);
        if (!session) {
            throw new SessionError("not_found", `Session not found: ${metadata.id}`);
        }
        return session;
    }
    async list() {
        return Promise.all([...this.sessions.values()].map((session) => session.getMetadata()));
    }
    async delete(metadata) {
        this.sessions.delete(metadata.id);
    }
    async fork(sourceMetadata, options) {
        const source = await this.open(sourceMetadata);
        const forkedEntries = await getEntriesToFork(source.getStorage(), options);
        const metadata = {
            id: options.id ?? createSessionId(),
            createdAt: createTimestamp(),
            forkedFrom: sourceMetadata.id,
        };
        const storage = new InMemorySessionStorage({ metadata, entries: forkedEntries });
        const session = toSession(storage);
        this.sessions.set(metadata.id, session);
        return session;
    }
    async exportEntries(sessionId) {
        const session = await this.open({ id: sessionId, createdAt: "" });
        return session.getStorage().getEntries();
    }
    async importEntries(sessionId, owner, entries, options) {
        void owner;
        const validated = validateEntriesForImport(entries, options);
        const metadata = { id: sessionId, createdAt: createTimestamp() };
        this.sessions.set(sessionId, toSession(new InMemorySessionStorage({ metadata, entries: validated })));
    }
}