telegram-agent-memory 0.2.1

package/dist/telegram/file-memory.d.ts

@@ -0,0 +1,72 @@
+import type { StoredLocalIndex } from './local-index';
+export interface StoredMemoryFact {
+    id: string;
+    kind: 'profile' | 'daily';
+    scope: 'user' | 'group';
+    userId?: string;
+    groupId: string;
+    content: string;
+    summary: string;
+    category: string;
+    tags: string[];
+    importance: number;
+    confidence: number;
+    sourceText: string;
+    createdAt: string;
+    updatedAt: string;
+    path: string;
+}
+export interface StoredProfile {
+    scope?: 'user' | 'group';
+    actor: {
+        userId: string;
+        groupId: string;
+        username?: string;
+    };
+    updatedAt: string;
+    facts: StoredMemoryFact[];
+}
+export interface StoredDailyLog {
+    date: string;
+    actor: {
+        userId: string;
+        groupId: string;
+        username?: string;
+    };
+    updatedAt: string;
+    entries: StoredMemoryFact[];
+}
+export declare class TelegramFileMemoryStore {
+    private readonly rootDir;
+    constructor(rootDir: string);
+    getRootDir(): string;
+    ensureReady(): Promise<void>;
+    private memberDir;
+    private userDir;
+    private profileJsonPath;
+    private profileMarkdownPath;
+    private sharedProfileJsonPath;
+    private sharedProfileMarkdownPath;
+    private dailyJsonPath;
+    private dailyMarkdownPath;
+    private localIndexPath;
+    readProfile(groupId: string, userId: string): Promise<StoredProfile>;
+    readSharedProfile(userId: string, groupId: string): Promise<StoredProfile>;
+    listGroupProfilesForUser(userId: string): Promise<StoredProfile[]>;
+    writeProfile(profile: StoredProfile): Promise<void>;
+    writeSharedProfile(profile: StoredProfile): Promise<void>;
+    readDailyLog(groupId: string, userId: string, dateKey: string): Promise<StoredDailyLog>;
+    writeDailyLog(daily: StoredDailyLog): Promise<void>;
+    readLocalIndex(groupId: string, userId: string): Promise<StoredLocalIndex>;
+    writeLocalIndex(groupId: string, userId: string, index: StoredLocalIndex): Promise<void>;
+    listRecentDailyLogs(groupId: string, userId: string, limit: number): Promise<StoredDailyLog[]>;
+    getFactById(memoryId: string): Promise<StoredMemoryFact | null>;
+    getUserStats(groupId: string, userId: string): Promise<{
+        profileFacts: number;
+        dailyFacts: number;
+        totalFacts: number;
+        lastUpdatedAt?: string;
+    }>;
+    toRelativePath(absolutePath: string): string;
+    sortFactsByUpdatedAt(facts: StoredMemoryFact[]): StoredMemoryFact[];
+}

package/dist/telegram/file-memory.js

@@ -0,0 +1,325 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramFileMemoryStore = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+function toPosixRelative(rootDir, absolutePath) {
+    return node_path_1.default.relative(rootDir, absolutePath).replace(/\\/g, '/');
+}
+async function readJsonFile(filePath, fallback) {
+    try {
+        const raw = await promises_1.default.readFile(filePath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT') {
+            return fallback;
+        }
+        throw error;
+    }
+}
+async function writeTextFile(filePath, content) {
+    await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+    await promises_1.default.writeFile(filePath, content, 'utf8');
+}
+function escapeMarkdown(value) {
+    return value.replace(/\r\n/g, '\n').trim();
+}
+function renderProfileMarkdown(profile) {
+    const lines = [
+        '# Member Profile',
+        '',
+        `- scope: ${profile.scope ?? 'group'}`,
+        `- userId: ${profile.actor.userId}`,
+        `- groupId: ${profile.actor.groupId}`,
+    ];
+    if (profile.actor.username) {
+        lines.push(`- username: ${profile.actor.username}`);
+    }
+    lines.push(`- updatedAt: ${profile.updatedAt}`, '');
+    if (profile.facts.length === 0) {
+        lines.push('No long-term memory yet.', '');
+        return `${lines.join('\n')}\n`;
+    }
+    for (const fact of profile.facts) {
+        lines.push(`## ${escapeMarkdown(fact.summary)}`);
+        lines.push(`- id: ${fact.id}`);
+        lines.push(`- kind: ${fact.kind}`);
+        lines.push(`- category: ${fact.category}`);
+        lines.push(`- importance: ${fact.importance}`);
+        lines.push(`- confidence: ${fact.confidence}`);
+        if (fact.tags.length > 0) {
+            lines.push(`- tags: ${fact.tags.join(', ')}`);
+        }
+        lines.push(`- updatedAt: ${fact.updatedAt}`);
+        lines.push('');
+        lines.push(escapeMarkdown(fact.content));
+        lines.push('');
+    }
+    return `${lines.join('\n')}\n`;
+}
+function renderDailyMarkdown(daily) {
+    const lines = [
+        `# Daily Memory ${daily.date}`,
+        '',
+        `- userId: ${daily.actor.userId}`,
+        `- groupId: ${daily.actor.groupId}`,
+    ];
+    if (daily.actor.username) {
+        lines.push(`- username: ${daily.actor.username}`);
+    }
+    lines.push(`- updatedAt: ${daily.updatedAt}`, '');
+    if (daily.entries.length === 0) {
+        lines.push('No daily memory yet.', '');
+        return `${lines.join('\n')}\n`;
+    }
+    for (const entry of daily.entries) {
+        lines.push(`## ${escapeMarkdown(entry.summary)}`);
+        lines.push(`- id: ${entry.id}`);
+        lines.push(`- category: ${entry.category}`);
+        lines.push(`- importance: ${entry.importance}`);
+        lines.push(`- confidence: ${entry.confidence}`);
+        if (entry.tags.length > 0) {
+            lines.push(`- tags: ${entry.tags.join(', ')}`);
+        }
+        lines.push(`- createdAt: ${entry.createdAt}`);
+        lines.push('');
+        lines.push(escapeMarkdown(entry.content));
+        lines.push('');
+    }
+    return `${lines.join('\n')}\n`;
+}
+function compareByUpdatedAt(a, b) {
+    return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+}
+class TelegramFileMemoryStore {
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    getRootDir() {
+        return this.rootDir;
+    }
+    async ensureReady() {
+        await promises_1.default.mkdir(this.rootDir, { recursive: true });
+    }
+    memberDir(groupId, userId) {
+        return node_path_1.default.join(this.rootDir, 'groups', groupId, 'members', userId);
+    }
+    userDir(userId) {
+        return node_path_1.default.join(this.rootDir, 'users', userId);
+    }
+    profileJsonPath(groupId, userId) {
+        return node_path_1.default.join(this.memberDir(groupId, userId), 'PROFILE.json');
+    }
+    profileMarkdownPath(groupId, userId) {
+        return node_path_1.default.join(this.memberDir(groupId, userId), 'PROFILE.md');
+    }
+    sharedProfileJsonPath(userId) {
+        return node_path_1.default.join(this.userDir(userId), 'PROFILE.json');
+    }
+    sharedProfileMarkdownPath(userId) {
+        return node_path_1.default.join(this.userDir(userId), 'PROFILE.md');
+    }
+    dailyJsonPath(groupId, userId, dateKey) {
+        return node_path_1.default.join(this.memberDir(groupId, userId), 'memory', `${dateKey}.json`);
+    }
+    dailyMarkdownPath(groupId, userId, dateKey) {
+        return node_path_1.default.join(this.memberDir(groupId, userId), 'memory', `${dateKey}.md`);
+    }
+    localIndexPath(groupId, userId) {
+        return node_path_1.default.join(this.memberDir(groupId, userId), 'INDEX.json');
+    }
+    async readProfile(groupId, userId) {
+        return readJsonFile(this.profileJsonPath(groupId, userId), {
+            scope: 'group',
+            actor: { userId, groupId },
+            updatedAt: new Date(0).toISOString(),
+            facts: [],
+        });
+    }
+    async readSharedProfile(userId, groupId) {
+        return readJsonFile(this.sharedProfileJsonPath(userId), {
+            scope: 'user',
+            actor: { userId, groupId },
+            updatedAt: new Date(0).toISOString(),
+            facts: [],
+        });
+    }
+    async listGroupProfilesForUser(userId) {
+        const groupsDir = node_path_1.default.join(this.rootDir, 'groups');
+        try {
+            const entries = await promises_1.default.readdir(groupsDir, { withFileTypes: true, encoding: 'utf8' });
+            const profiles = [];
+            for (const entry of entries) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                const profilePath = this.profileJsonPath(entry.name, userId);
+                try {
+                    const raw = await promises_1.default.readFile(profilePath, 'utf8');
+                    profiles.push(JSON.parse(raw));
+                }
+                catch (error) {
+                    const code = error.code;
+                    if (code === 'ENOENT') {
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+            return profiles;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async writeProfile(profile) {
+        const nextProfile = {
+            ...profile,
+            scope: 'group',
+        };
+        const filePath = this.profileJsonPath(profile.actor.groupId, profile.actor.userId);
+        await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+        await promises_1.default.writeFile(filePath, `${JSON.stringify(nextProfile, null, 2)}\n`, 'utf8');
+        await writeTextFile(this.profileMarkdownPath(profile.actor.groupId, profile.actor.userId), renderProfileMarkdown(nextProfile));
+    }
+    async writeSharedProfile(profile) {
+        const sharedPath = this.toRelativePath(this.sharedProfileMarkdownPath(profile.actor.userId));
+        const nextProfile = {
+            ...profile,
+            scope: 'user',
+            facts: profile.facts.map((fact) => ({
+                ...fact,
+                path: sharedPath,
+            })),
+        };
+        const filePath = this.sharedProfileJsonPath(profile.actor.userId);
+        await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+        await promises_1.default.writeFile(filePath, `${JSON.stringify(nextProfile, null, 2)}\n`, 'utf8');
+        await writeTextFile(this.sharedProfileMarkdownPath(profile.actor.userId), renderProfileMarkdown(nextProfile));
+    }
+    async readDailyLog(groupId, userId, dateKey) {
+        return readJsonFile(this.dailyJsonPath(groupId, userId, dateKey), {
+            date: dateKey,
+            actor: { userId, groupId },
+            updatedAt: new Date(0).toISOString(),
+            entries: [],
+        });
+    }
+    async writeDailyLog(daily) {
+        const filePath = this.dailyJsonPath(daily.actor.groupId, daily.actor.userId, daily.date);
+        await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+        await promises_1.default.writeFile(filePath, `${JSON.stringify(daily, null, 2)}\n`, 'utf8');
+        await writeTextFile(this.dailyMarkdownPath(daily.actor.groupId, daily.actor.userId, daily.date), renderDailyMarkdown(daily));
+    }
+    async readLocalIndex(groupId, userId) {
+        return readJsonFile(this.localIndexPath(groupId, userId), {
+            version: 1,
+            model: '',
+            updatedAt: new Date(0).toISOString(),
+            entries: [],
+        });
+    }
+    async writeLocalIndex(groupId, userId, index) {
+        const filePath = this.localIndexPath(groupId, userId);
+        await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+        await promises_1.default.writeFile(filePath, `${JSON.stringify(index, null, 2)}\n`, 'utf8');
+    }
+    async listRecentDailyLogs(groupId, userId, limit) {
+        const memoryDir = node_path_1.default.join(this.memberDir(groupId, userId), 'memory');
+        try {
+            const entries = await promises_1.default.readdir(memoryDir, { withFileTypes: true, encoding: 'utf8' });
+            const jsonFiles = entries
+                .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+                .map((entry) => entry.name)
+                .sort()
+                .reverse()
+                .slice(0, limit);
+            return Promise.all(jsonFiles.map((name) => readJsonFile(node_path_1.default.join(memoryDir, name), {
+                date: name.replace(/\.json$/, ''),
+                actor: { userId, groupId },
+                updatedAt: new Date(0).toISOString(),
+                entries: [],
+            })));
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async getFactById(memoryId) {
+        const search = async (dir) => {
+            try {
+                const entries = await promises_1.default.readdir(dir, { withFileTypes: true, encoding: 'utf8' });
+                for (const entry of entries) {
+                    const fullPath = node_path_1.default.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        const nested = await search(fullPath);
+                        if (nested) {
+                            return nested;
+                        }
+                        continue;
+                    }
+                    if (!entry.isFile() || !entry.name.endsWith('.json')) {
+                        continue;
+                    }
+                    const payload = await readJsonFile(fullPath, {});
+                    const fact = payload.facts?.find((item) => item.id === memoryId) ??
+                        payload.entries?.find((item) => item.id === memoryId);
+                    if (fact) {
+                        return fact;
+                    }
+                }
+            }
+            catch (error) {
+                const code = error.code;
+                if (code === 'ENOENT') {
+                    return null;
+                }
+                throw error;
+            }
+            return null;
+        };
+        for (const searchRoot of [
+            node_path_1.default.join(this.rootDir, 'users'),
+            node_path_1.default.join(this.rootDir, 'groups'),
+        ]) {
+            const fact = await search(searchRoot);
+            if (fact) {
+                return fact;
+            }
+        }
+        return null;
+    }
+    async getUserStats(groupId, userId) {
+        const profile = await this.readProfile(groupId, userId);
+        const dailies = await this.listRecentDailyLogs(groupId, userId, 3650);
+        const dailyFacts = dailies.reduce((sum, daily) => sum + daily.entries.length, 0);
+        const timestamps = [profile.updatedAt, ...dailies.map((daily) => daily.updatedAt)].filter((value) => value && value !== new Date(0).toISOString());
+        timestamps.sort();
+        return {
+            profileFacts: profile.facts.length,
+            dailyFacts,
+            totalFacts: profile.facts.length + dailyFacts,
+            lastUpdatedAt: timestamps.at(-1),
+        };
+    }
+    toRelativePath(absolutePath) {
+        return toPosixRelative(this.rootDir, absolutePath);
+    }
+    sortFactsByUpdatedAt(facts) {
+        return [...facts].sort(compareByUpdatedAt);
+    }
+}
+exports.TelegramFileMemoryStore = TelegramFileMemoryStore;

package/dist/telegram/local-index.d.ts

@@ -0,0 +1,53 @@
+import type { StoredMemoryFact } from './file-memory';
+export interface TelegramEmbeddingProvider {
+    readonly model: string;
+    embed(texts: string[]): Promise<number[][]>;
+}
+export interface StoredLocalIndexEntry {
+    factId: string;
+    kind: 'profile' | 'daily';
+    path: string;
+    updatedAt: string;
+    summary: string;
+    content: string;
+    category: string;
+    tags: string[];
+    importance: number;
+    embedding: number[];
+}
+export interface StoredLocalIndex {
+    version: 1;
+    model: string;
+    updatedAt: string;
+    entries: StoredLocalIndexEntry[];
+}
+export declare class LocalEmbeddingProvider implements TelegramEmbeddingProvider {
+    readonly model: string;
+    private readonly dimensions;
+    constructor(config?: {
+        dimensions?: number;
+        model?: string;
+    });
+    embed(texts: string[]): Promise<number[][]>;
+}
+export declare class OpenAIEmbeddingProvider implements TelegramEmbeddingProvider {
+    readonly model: string;
+    private readonly client;
+    constructor(config: {
+        apiKey: string;
+        baseURL?: string;
+        model?: string;
+        headers?: Record<string, string>;
+    });
+    embed(texts: string[]): Promise<number[][]>;
+}
+export declare function buildEmbeddingInput(fact: Pick<StoredMemoryFact, 'summary' | 'content' | 'category' | 'tags'>): string;
+export declare function cosineSimilarity(left: number[], right: number[]): number;
+export declare function tokenizeQuery(query: string): string[];
+export declare function scoreIndexedEntry(params: {
+    entry: StoredLocalIndexEntry;
+    query: string;
+    queryTokens: string[];
+    queryEmbedding?: number[] | null;
+    now: Date;
+}): number;

package/dist/telegram/local-index.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIEmbeddingProvider = exports.LocalEmbeddingProvider = void 0;
+exports.buildEmbeddingInput = buildEmbeddingInput;
+exports.cosineSimilarity = cosineSimilarity;
+exports.tokenizeQuery = tokenizeQuery;
+exports.scoreIndexedEntry = scoreIndexedEntry;
+const openai_1 = __importDefault(require("openai"));
+const DEFAULT_EMBEDDING_MODEL = 'text-embedding-3-small';
+const DEFAULT_LOCAL_DIMENSIONS = 64;
+function embedTextLocally(text, dimensions) {
+    const vector = new Array(dimensions).fill(0);
+    const tokens = text
+        .toLowerCase()
+        .split(/[^\p{L}\p{N}]+/u)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 1);
+    if (tokens.length === 0) {
+        return vector;
+    }
+    for (const token of tokens) {
+        let hash = 0;
+        for (let index = 0; index < token.length; index += 1) {
+            hash = (hash * 31 + token.charCodeAt(index)) >>> 0;
+        }
+        vector[hash % dimensions] += 1;
+    }
+    const norm = Math.sqrt(vector.reduce((sum, value) => sum + value * value, 0));
+    if (norm === 0) {
+        return vector;
+    }
+    return vector.map((value) => value / norm);
+}
+class LocalEmbeddingProvider {
+    constructor(config = {}) {
+        this.dimensions = config.dimensions ?? DEFAULT_LOCAL_DIMENSIONS;
+        this.model = config.model ?? `local-hash-${this.dimensions}`;
+    }
+    async embed(texts) {
+        return texts.map((text) => embedTextLocally(text, this.dimensions));
+    }
+}
+exports.LocalEmbeddingProvider = LocalEmbeddingProvider;
+class OpenAIEmbeddingProvider {
+    constructor(config) {
+        this.client = new openai_1.default({
+            apiKey: config.apiKey,
+            baseURL: config.baseURL,
+            defaultHeaders: config.headers,
+        });
+        this.model = config.model?.trim() || DEFAULT_EMBEDDING_MODEL;
+    }
+    async embed(texts) {
+        if (texts.length === 0) {
+            return [];
+        }
+        const response = await this.client.embeddings.create({
+            model: this.model,
+            input: texts,
+        });
+        return response.data
+            .slice()
+            .sort((left, right) => left.index - right.index)
+            .map((item) => item.embedding);
+    }
+}
+exports.OpenAIEmbeddingProvider = OpenAIEmbeddingProvider;
+function buildEmbeddingInput(fact) {
+    return [
+        fact.summary.trim(),
+        fact.content.trim(),
+        fact.category.trim(),
+        fact.tags.join(' ').trim(),
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+function cosineSimilarity(left, right) {
+    if (left.length === 0 || right.length === 0 || left.length !== right.length) {
+        return 0;
+    }
+    let dot = 0;
+    let leftNorm = 0;
+    let rightNorm = 0;
+    for (let index = 0; index < left.length; index += 1) {
+        dot += left[index] * right[index];
+        leftNorm += left[index] * left[index];
+        rightNorm += right[index] * right[index];
+    }
+    if (leftNorm === 0 || rightNorm === 0) {
+        return 0;
+    }
+    return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
+}
+function tokenizeQuery(query) {
+    return Array.from(new Set(query
+        .toLowerCase()
+        .split(/[^\p{L}\p{N}]+/u)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 1)));
+}
+function scoreIndexedEntry(params) {
+    const haystack = [
+        params.entry.summary,
+        params.entry.content,
+        params.entry.category,
+        params.entry.tags.join(' '),
+    ]
+        .join('\n')
+        .toLowerCase();
+    const lexicalMatches = params.queryTokens.filter((token) => haystack.includes(token)).length;
+    const lexicalScore = params.queryTokens.length === 0 ? 0 : lexicalMatches / params.queryTokens.length;
+    const exactPhraseBoost = haystack.includes(params.query.trim().toLowerCase()) ? 0.12 : 0;
+    const embeddingScore = params.queryEmbedding
+        ? Math.max(0, cosineSimilarity(params.queryEmbedding, params.entry.embedding))
+        : 0;
+    const ageDays = Math.max(0, (params.now.getTime() - new Date(params.entry.updatedAt).getTime()) / (24 * 60 * 60 * 1000));
+    const recencyScore = params.entry.kind === 'daily' ? Math.max(0, 1 - ageDays / 14) : 0.4;
+    if (params.queryEmbedding) {
+        return (embeddingScore * 0.55 +
+            lexicalScore * 0.2 +
+            params.entry.importance * 0.15 +
+            recencyScore * 0.1 +
+            exactPhraseBoost);
+    }
+    return (lexicalScore * 0.55 + params.entry.importance * 0.25 + recencyScore * 0.2 + exactPhraseBoost);
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "telegram-agent-memory",
+  "version": "0.2.1",
+  "description": "File-first long-term memory for Telegram bots and group members",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.build.json --noEmit",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint . --ext .ts",
+    "prepack": "npm run build",
+    "pack:check": "npm pack --dry-run --cache .npm-cache",
+    "release:check": "npm run verify && npm run pack:check",
+    "test": "jest --coverage --runInBand",
+    "test:unit": "jest --runInBand tests/unit/package-manifest.test.ts tests/unit/telegram-memory.test.ts tests/unit/telegram-memory-evaluation.test.ts",
+    "test:telegram-memory": "jest --runInBand tests/unit/package-manifest.test.ts tests/unit/telegram-memory.test.ts tests/unit/telegram-memory-evaluation.test.ts",
+    "test:telegram-memory:eval": "jest --runInBand tests/unit/telegram-memory-evaluation.test.ts",
+    "test:watch": "jest --watch",
+    "verify": "npm run format:check && npm run lint && npm run build && npm run typecheck && npm run test",
+    "dev": "tsc --watch"
+  },
+  "keywords": [
+    "telegram",
+    "agent",
+    "memory",
+    "markdown",
+    "file-first",
+    "ai"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "author": "",
+  "license": "MIT",
+  "sideEffects": false,
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.12.7",
+    "@types/uuid": "^9.0.8",
+    "eslint": "^9.25.1",
+    "globals": "^16.0.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.5.3",
+    "ts-jest": "^29.1.2",
+    "typescript-eslint": "^8.30.1",
+    "typescript": "^5.4.5",
+    "uuid": "^9.0.1"
+  },
+  "dependencies": {
+    "openai": "^4.28.4"
+  }
+}