@arkheia/mcp-server 1.2.0 → 1.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/memory.js ADDED
@@ -0,0 +1,187 @@
1
+ "use strict";
2
+ var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
3
+ if (k2 === undefined) k2 = k;
4
+ var desc = Object.getOwnPropertyDescriptor(m, k);
5
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
6
+ desc = { enumerable: true, get: function() { return m[k]; } };
7
+ }
8
+ Object.defineProperty(o, k2, desc);
9
+ }) : (function(o, m, k, k2) {
10
+ if (k2 === undefined) k2 = k;
11
+ o[k2] = m[k];
12
+ }));
13
+ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
14
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
15
+ }) : function(o, v) {
16
+ o["default"] = v;
17
+ });
18
+ var __importStar = (this && this.__importStar) || (function () {
19
+ var ownKeys = function(o) {
20
+ ownKeys = Object.getOwnPropertyNames || function (o) {
21
+ var ar = [];
22
+ for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
23
+ return ar;
24
+ };
25
+ return ownKeys(o);
26
+ };
27
+ return function (mod) {
28
+ if (mod && mod.__esModule) return mod;
29
+ var result = {};
30
+ if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
31
+ __setModuleDefault(result, mod);
32
+ return result;
33
+ };
34
+ })();
35
+ var __importDefault = (this && this.__importDefault) || function (mod) {
36
+ return (mod && mod.__esModule) ? mod : { "default": mod };
37
+ };
38
+ Object.defineProperty(exports, "__esModule", { value: true });
39
+ exports.store_entity = store_entity;
40
+ exports.retrieve_entities = retrieve_entities;
41
+ exports.store_relation = store_relation;
42
+ const sql_js_1 = __importDefault(require("sql.js"));
43
+ const path = __importStar(require("path"));
44
+ const fs = __importStar(require("fs"));
45
+ const crypto = __importStar(require("crypto"));
46
+ const os = __importStar(require("os"));
47
+ const logger = console;
48
+ // ---------------------------------------------------------------------------
49
+ // DB setup — sql.js (pure JS, no native module)
50
+ // ---------------------------------------------------------------------------
51
+ function _db_path() {
52
+ return process.env.MEMORY_DB_PATH || path.join(os.homedir(), '.arkheia', 'memory.db');
53
+ }
54
+ let _db = null;
55
+ let _dbReady = null;
56
+ function _getDb() {
57
+ if (_dbReady)
58
+ return _dbReady;
59
+ _dbReady = (async () => {
60
+ const SQL = await (0, sql_js_1.default)();
61
+ const dbPath = _db_path();
62
+ const dir = path.dirname(dbPath);
63
+ if (!fs.existsSync(dir)) {
64
+ fs.mkdirSync(dir, { recursive: true });
65
+ }
66
+ // Load existing DB or create new
67
+ if (fs.existsSync(dbPath)) {
68
+ const buffer = fs.readFileSync(dbPath);
69
+ _db = new SQL.Database(buffer);
70
+ }
71
+ else {
72
+ _db = new SQL.Database();
73
+ }
74
+ // Init schema
75
+ _db.run(`
76
+ CREATE TABLE IF NOT EXISTS entities (
77
+ entity_id TEXT PRIMARY KEY,
78
+ name TEXT NOT NULL,
79
+ entity_type TEXT NOT NULL,
80
+ created_at TEXT NOT NULL
81
+ );
82
+ CREATE TABLE IF NOT EXISTS observations (
83
+ obs_id TEXT PRIMARY KEY,
84
+ entity_id TEXT NOT NULL REFERENCES entities(entity_id),
85
+ content TEXT NOT NULL,
86
+ created_at TEXT NOT NULL
87
+ );
88
+ CREATE TABLE IF NOT EXISTS relations (
89
+ rel_id TEXT PRIMARY KEY,
90
+ from_entity TEXT NOT NULL,
91
+ relation_type TEXT NOT NULL,
92
+ to_entity TEXT NOT NULL,
93
+ created_at TEXT NOT NULL
94
+ );
95
+ `);
96
+ _save(_db);
97
+ return _db;
98
+ })();
99
+ return _dbReady;
100
+ }
101
+ function _save(db) {
102
+ const data = db.export();
103
+ const buffer = Buffer.from(data);
104
+ fs.writeFileSync(_db_path(), buffer);
105
+ }
106
+ // ---------------------------------------------------------------------------
107
+ // Public functions
108
+ // ---------------------------------------------------------------------------
109
+ async function store_entity(name, entity_type, observations) {
110
+ const db = await _getDb();
111
+ const now = new Date().toISOString();
112
+ // Upsert entity — look up by name+type
113
+ let entity_id;
114
+ const existing = db.exec("SELECT entity_id FROM entities WHERE name = ? AND entity_type = ?", [name, entity_type]);
115
+ if (existing.length > 0 && existing[0].values.length > 0) {
116
+ entity_id = existing[0].values[0][0];
117
+ }
118
+ else {
119
+ entity_id = crypto.randomUUID();
120
+ db.run("INSERT INTO entities (entity_id, name, entity_type, created_at) VALUES (?, ?, ?, ?)", [entity_id, name, entity_type, now]);
121
+ }
122
+ // Fetch existing observation contents to deduplicate
123
+ const existingObs = db.exec("SELECT content FROM observations WHERE entity_id = ?", [entity_id]);
124
+ const existingContentSet = new Set();
125
+ if (existingObs.length > 0) {
126
+ for (const row of existingObs[0].values) {
127
+ existingContentSet.add(row[0]);
128
+ }
129
+ }
130
+ let added = 0;
131
+ for (const content of observations) {
132
+ if (!existingContentSet.has(content)) {
133
+ db.run("INSERT INTO observations (obs_id, entity_id, content, created_at) VALUES (?, ?, ?, ?)", [crypto.randomUUID(), entity_id, content, now]);
134
+ existingContentSet.add(content);
135
+ added++;
136
+ }
137
+ }
138
+ const countResult = db.exec("SELECT COUNT(*) AS n FROM observations WHERE entity_id = ?", [entity_id]);
139
+ const totalObservations = countResult.length > 0 ? countResult[0].values[0][0] : 0;
140
+ _save(db);
141
+ return {
142
+ entity_id,
143
+ name,
144
+ entity_type,
145
+ observations_added: added,
146
+ total_observations: totalObservations,
147
+ };
148
+ }
149
+ async function retrieve_entities(query, entity_type = undefined, limit = 10) {
150
+ const db = await _getDb();
151
+ const pattern = `%${query}%`;
152
+ let rows;
153
+ if (entity_type) {
154
+ const result = db.exec("SELECT entity_id, name, entity_type, created_at FROM entities WHERE name LIKE ? AND entity_type = ?", [pattern, entity_type]);
155
+ rows = result.length > 0 ? result[0].values.map(r => ({ entity_id: r[0], name: r[1], entity_type: r[2], created_at: r[3] })) : [];
156
+ }
157
+ else {
158
+ const result = db.exec("SELECT entity_id, name, entity_type, created_at FROM entities WHERE name LIKE ?", [pattern]);
159
+ rows = result.length > 0 ? result[0].values.map(r => ({ entity_id: r[0], name: r[1], entity_type: r[2], created_at: r[3] })) : [];
160
+ }
161
+ const total = rows.length;
162
+ rows = rows.slice(0, Math.min(limit, 50));
163
+ const entities = [];
164
+ for (const row of rows) {
165
+ const obsResult = db.exec("SELECT content, created_at FROM observations WHERE entity_id = ? ORDER BY created_at", [row.entity_id]);
166
+ const obs = obsResult.length > 0 ? obsResult[0].values.map(o => ({ content: o[0], created_at: o[1] })) : [];
167
+ const relResult = db.exec("SELECT relation_type, to_entity FROM relations WHERE from_entity = ? ORDER BY created_at", [row.name]);
168
+ const rels = relResult.length > 0 ? relResult[0].values.map(r => ({ relation_type: r[0], to_entity: r[1] })) : [];
169
+ entities.push({
170
+ entity_id: row.entity_id,
171
+ name: row.name,
172
+ entity_type: row.entity_type,
173
+ created_at: row.created_at,
174
+ observations: obs,
175
+ relations: rels,
176
+ });
177
+ }
178
+ return { entities, total };
179
+ }
180
+ async function store_relation(from_entity, relation_type, to_entity) {
181
+ const db = await _getDb();
182
+ const rel_id = crypto.randomUUID();
183
+ const now = new Date().toISOString();
184
+ db.run("INSERT INTO relations (rel_id, from_entity, relation_type, to_entity, created_at) VALUES (?, ?, ?, ?, ?)", [rel_id, from_entity, relation_type, to_entity, now]);
185
+ _save(db);
186
+ return { rel_id, from_entity, relation_type, to_entity };
187
+ }
@@ -0,0 +1,320 @@
1
+ "use strict";
2
+ var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
3
+ if (k2 === undefined) k2 = k;
4
+ var desc = Object.getOwnPropertyDescriptor(m, k);
5
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
6
+ desc = { enumerable: true, get: function() { return m[k]; } };
7
+ }
8
+ Object.defineProperty(o, k2, desc);
9
+ }) : (function(o, m, k, k2) {
10
+ if (k2 === undefined) k2 = k;
11
+ o[k2] = m[k];
12
+ }));
13
+ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
14
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
15
+ }) : function(o, v) {
16
+ o["default"] = v;
17
+ });
18
+ var __importStar = (this && this.__importStar) || (function () {
19
+ var ownKeys = function(o) {
20
+ ownKeys = Object.getOwnPropertyNames || function (o) {
21
+ var ar = [];
22
+ for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
23
+ return ar;
24
+ };
25
+ return ownKeys(o);
26
+ };
27
+ return function (mod) {
28
+ if (mod && mod.__esModule) return mod;
29
+ var result = {};
30
+ if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
31
+ __setModuleDefault(result, mod);
32
+ return result;
33
+ };
34
+ })();
35
+ Object.defineProperty(exports, "__esModule", { value: true });
36
+ exports.call_grok = call_grok;
37
+ exports.call_gemini = call_gemini;
38
+ exports.call_together = call_together;
39
+ exports.call_ollama = call_ollama;
40
+ const crypto = __importStar(require("crypto"));
41
+ // Node.js native fetch doesn't have a global logger, use console
42
+ const logger = console;
43
+ const _DEFAULT_TIMEOUT = 60 * 1000; // 60 seconds in milliseconds
44
+ const _OLLAMA_TIMEOUT = 120 * 1000; // 120 seconds in milliseconds
45
+ // ---------------------------------------------------------------------------
46
+ // Internal helpers
47
+ // ---------------------------------------------------------------------------
48
+ function _prompt_hash(prompt) {
49
+ return crypto.createHash('sha256').update(prompt).digest('hex');
50
+ }
51
+ function _err_response(model, prompt, error) {
52
+ return {
53
+ response: `[provider_error: ${error}]`,
54
+ model: model,
55
+ prompt_hash: _prompt_hash(prompt),
56
+ error: error,
57
+ };
58
+ }
59
+ // ---------------------------------------------------------------------------
60
+ // Grok (xAI) — OpenAI-compatible /v1/chat/completions
61
+ // ---------------------------------------------------------------------------
62
+ async function call_grok(prompt, model = "grok-4-fast-non-reasoning", kwargs = {}) {
63
+ /**
64
+ * Call xAI Grok chat completions API.
65
+ *
66
+ * Returns: {response, model, prompt_hash, error}
67
+ */
68
+ const api_key = process.env.XAI_API_KEY;
69
+ if (!api_key) {
70
+ return _err_response(model, prompt, "XAI_API_KEY not set");
71
+ }
72
+ const controller = new AbortController();
73
+ const timeoutId = setTimeout(() => controller.abort(), _DEFAULT_TIMEOUT);
74
+ try {
75
+ const resp = await fetch("https://api.x.ai/v1/chat/completions", {
76
+ method: "POST",
77
+ headers: {
78
+ "Authorization": `Bearer ${api_key}`,
79
+ "Content-Type": "application/json",
80
+ },
81
+ body: JSON.stringify({
82
+ model: model,
83
+ messages: [{ role: "user", content: prompt }],
84
+ ...kwargs,
85
+ }),
86
+ signal: controller.signal,
87
+ });
88
+ clearTimeout(timeoutId);
89
+ if (!resp.ok) {
90
+ logger.error(`call_grok: HTTP ${resp.status} for model=${model}`);
91
+ return _err_response(model, prompt, `http_${resp.status}`);
92
+ }
93
+ const data = await resp.json();
94
+ const response_text = data.choices?.[0]?.message?.content;
95
+ if (typeof response_text !== 'string') {
96
+ throw new Error("Invalid response format from Grok API");
97
+ }
98
+ return {
99
+ response: response_text,
100
+ model: model,
101
+ prompt_hash: _prompt_hash(prompt),
102
+ usage: data.usage || {},
103
+ error: null,
104
+ };
105
+ }
106
+ catch (e) {
107
+ clearTimeout(timeoutId);
108
+ if (e.name === 'AbortError') {
109
+ logger.error(`call_grok: request timed out for model=${model}`);
110
+ return _err_response(model, prompt, "timeout");
111
+ }
112
+ else if (e.name === 'TypeError' && e.message.includes('fetch failed')) {
113
+ logger.error(`call_grok: network error for model=${model}: ${e.message}`);
114
+ return _err_response(model, prompt, "network_error");
115
+ }
116
+ else {
117
+ logger.error(`call_grok: unexpected error: ${e.message}`);
118
+ return _err_response(model, prompt, e.message);
119
+ }
120
+ }
121
+ }
122
+ // ---------------------------------------------------------------------------
123
+ // Gemini (Google) — generateContent REST API
124
+ // ---------------------------------------------------------------------------
125
+ async function call_gemini(prompt, model = "gemini-2.5-flash", max_output_tokens = 1000, kwargs = {}) {
126
+ /**
127
+ * Call Google Gemini generateContent API.
128
+ *
129
+ * Note: gemini-2.5-flash and -pro are thinking models — they need
130
+ * max_output_tokens >= 1000 to produce content after thinking tokens.
131
+ *
132
+ * Returns: {response, model, prompt_hash, error}
133
+ */
134
+ const api_key = process.env.GOOGLE_API_KEY;
135
+ if (!api_key) {
136
+ return _err_response(model, prompt, "GOOGLE_API_KEY not set");
137
+ }
138
+ const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`;
139
+ const controller = new AbortController();
140
+ const timeoutId = setTimeout(() => controller.abort(), _DEFAULT_TIMEOUT);
141
+ try {
142
+ const resp = await fetch(`${url}?key=${api_key}`, {
143
+ method: "POST",
144
+ headers: {
145
+ "Content-Type": "application/json",
146
+ },
147
+ body: JSON.stringify({
148
+ contents: [{ parts: [{ text: prompt }] }],
149
+ generationConfig: {
150
+ maxOutputTokens: max_output_tokens,
151
+ ...kwargs,
152
+ },
153
+ }),
154
+ signal: controller.signal,
155
+ });
156
+ clearTimeout(timeoutId);
157
+ if (!resp.ok) {
158
+ logger.error(`call_gemini: HTTP ${resp.status} for model=${model}`);
159
+ return _err_response(model, prompt, `http_${resp.status}`);
160
+ }
161
+ const data = await resp.json();
162
+ const response_text = data.candidates?.[0]?.content?.parts?.[0]?.text;
163
+ if (typeof response_text !== 'string') {
164
+ throw new Error("Invalid response format from Gemini API");
165
+ }
166
+ return {
167
+ response: response_text,
168
+ model: model,
169
+ prompt_hash: _prompt_hash(prompt),
170
+ usage: data.usageMetadata || {},
171
+ error: null,
172
+ };
173
+ }
174
+ catch (e) {
175
+ clearTimeout(timeoutId);
176
+ if (e.name === 'AbortError') {
177
+ logger.error(`call_gemini: request timed out for model=${model}`);
178
+ return _err_response(model, prompt, "timeout");
179
+ }
180
+ else if (e.name === 'TypeError' && e.message.includes('fetch failed')) {
181
+ logger.error(`call_gemini: network error for model=${model}: ${e.message}`);
182
+ return _err_response(model, prompt, "network_error");
183
+ }
184
+ else {
185
+ logger.error(`call_gemini: unexpected error: ${e.message}`);
186
+ return _err_response(model, prompt, e.message);
187
+ }
188
+ }
189
+ }
190
+ // ---------------------------------------------------------------------------
191
+ // Together AI — OpenAI-compatible, cloud inference
192
+ // ---------------------------------------------------------------------------
193
+ async function call_together(prompt, model = "moonshotai/Kimi-K2.5", max_tokens = 2048, kwargs = {}) {
194
+ /**
195
+ * Call Together AI chat completions API (OpenAI-compatible).
196
+ *
197
+ * Default model is Kimi K2.5 — a thinking model that consumes
198
+ * 100-500 tokens internally before producing output, so max_tokens
199
+ * must be >= 2048 to reliably get a response.
200
+ *
201
+ * Returns: {response, model, prompt_hash, usage, error}
202
+ */
203
+ const api_key = process.env.TOGETHER_API_KEY;
204
+ if (!api_key) {
205
+ return _err_response(model, prompt, "TOGETHER_API_KEY not set");
206
+ }
207
+ const controller = new AbortController();
208
+ const timeoutId = setTimeout(() => controller.abort(), _DEFAULT_TIMEOUT);
209
+ try {
210
+ const resp = await fetch("https://api.together.xyz/v1/chat/completions", {
211
+ method: "POST",
212
+ headers: {
213
+ "Authorization": `Bearer ${api_key}`,
214
+ "Content-Type": "application/json",
215
+ },
216
+ body: JSON.stringify({
217
+ model: model,
218
+ max_tokens: max_tokens,
219
+ messages: [{ role: "user", content: prompt }],
220
+ ...kwargs,
221
+ }),
222
+ signal: controller.signal,
223
+ });
224
+ clearTimeout(timeoutId);
225
+ if (!resp.ok) {
226
+ logger.error(`call_together: HTTP ${resp.status} for model=${model}`);
227
+ return _err_response(model, prompt, `http_${resp.status}`);
228
+ }
229
+ const data = await resp.json();
230
+ const response_text = data.choices?.[0]?.message?.content;
231
+ if (typeof response_text !== 'string') {
232
+ throw new Error("Invalid response format from Together AI API");
233
+ }
234
+ return {
235
+ response: response_text,
236
+ model: model,
237
+ prompt_hash: _prompt_hash(prompt),
238
+ usage: data.usage || {},
239
+ error: null,
240
+ };
241
+ }
242
+ catch (e) {
243
+ clearTimeout(timeoutId);
244
+ if (e.name === 'AbortError') {
245
+ logger.error(`call_together: request timed out for model=${model}`);
246
+ return _err_response(model, prompt, "timeout");
247
+ }
248
+ else if (e.name === 'TypeError' && e.message.includes('fetch failed')) {
249
+ logger.error(`call_together: network error for model=${model}: ${e.message}`);
250
+ return _err_response(model, prompt, "network_error");
251
+ }
252
+ else {
253
+ logger.error(`call_together: unexpected error: ${e.message}`);
254
+ return _err_response(model, prompt, e.message);
255
+ }
256
+ }
257
+ }
258
+ // ---------------------------------------------------------------------------
259
+ // Ollama — local inference, no network egress
260
+ // ---------------------------------------------------------------------------
261
+ async function call_ollama(prompt, model = "phi4:14b", kwargs = {}) {
262
+ /**
263
+ * Call local Ollama model via /api/generate (non-streaming).
264
+ *
265
+ * OLLAMA_BASE_URL defaults to http://localhost:11434.
266
+ * No network egress — local eval only.
267
+ *
268
+ * Returns: {response, model, prompt_hash, eval_count, error}
269
+ */
270
+ const base_url = process.env.OLLAMA_BASE_URL || "http://localhost:11434";
271
+ const controller = new AbortController();
272
+ const timeoutId = setTimeout(() => controller.abort(), _OLLAMA_TIMEOUT);
273
+ try {
274
+ const resp = await fetch(`${base_url}/api/generate`, {
275
+ method: "POST",
276
+ headers: {
277
+ "Content-Type": "application/json",
278
+ },
279
+ body: JSON.stringify({
280
+ model: model,
281
+ prompt: prompt,
282
+ stream: false,
283
+ ...kwargs,
284
+ }),
285
+ signal: controller.signal,
286
+ });
287
+ clearTimeout(timeoutId);
288
+ if (!resp.ok) {
289
+ logger.error(`call_ollama: HTTP ${resp.status} for model=${model}`);
290
+ return _err_response(model, prompt, `http_${resp.status}`);
291
+ }
292
+ const data = await resp.json();
293
+ const response_text = data.response;
294
+ if (typeof response_text !== 'string') {
295
+ throw new Error("Invalid response format from Ollama API");
296
+ }
297
+ return {
298
+ response: response_text,
299
+ model: model,
300
+ prompt_hash: _prompt_hash(prompt),
301
+ eval_count: data.eval_count,
302
+ error: null,
303
+ };
304
+ }
305
+ catch (e) {
306
+ clearTimeout(timeoutId);
307
+ if (e.name === 'AbortError') {
308
+ logger.error(`call_ollama: request timed out for model=${model}`);
309
+ return _err_response(model, prompt, "timeout");
310
+ }
311
+ else if (e.name === 'TypeError' && e.message.includes('fetch failed')) {
312
+ logger.error(`call_ollama: cannot connect to Ollama at ${base_url}`);
313
+ return _err_response(model, prompt, "ollama_unavailable");
314
+ }
315
+ else {
316
+ logger.error(`call_ollama: unexpected error: ${e.message}`);
317
+ return _err_response(model, prompt, e.message);
318
+ }
319
+ }
320
+ }