354 lines
26 KiB
JavaScript
354 lines
26 KiB
JavaScript
import * as path from 'path';
|
|
import { toolLogger } from '../../index.js';
|
|
import { store, get, set } from './keyv.js';
|
|
// Helper function to get storage path
|
|
const getStoragePath = (options) => {
|
|
// For now, use default path. Later this can be configured via options
|
|
return path.join(process.cwd(), 'memory.sqlite');
|
|
};
|
|
// Default collection name when none provided
|
|
const DEFAULT_COLLECTION = 'no-collection';
|
|
// Helper function to process value based on format
|
|
const processValueForStorage = (value, format) => {
|
|
switch (format) {
|
|
case 'json':
|
|
try {
|
|
// Validate JSON by parsing and re-stringifying
|
|
JSON.parse(value);
|
|
return value;
|
|
}
|
|
catch (error) {
|
|
throw new Error('Invalid JSON format provided');
|
|
}
|
|
case 'binary':
|
|
// For binary, we expect base64 encoded data
|
|
try {
|
|
// Validate base64
|
|
Buffer.from(value, 'base64');
|
|
return value;
|
|
}
|
|
catch (error) {
|
|
throw new Error('Invalid base64 format for binary data');
|
|
}
|
|
case 'text':
|
|
default:
|
|
return value;
|
|
}
|
|
};
|
|
// Helper function to create memory entry
|
|
const createMemoryEntry = (value, format) => {
|
|
const now = new Date().toISOString();
|
|
return {
|
|
value: processValueForStorage(value, format),
|
|
meta: {
|
|
type: format,
|
|
created: now,
|
|
updated: now
|
|
}
|
|
};
|
|
};
|
|
export const tools = (target, options) => {
|
|
const logger = toolLogger('memory', options);
|
|
const storagePath = getStoragePath(options);
|
|
return [
|
|
{
|
|
type: 'function',
|
|
function: {
|
|
name: 'memorize',
|
|
description: `Store information in memory as a key-value collection with format support. Supports text, JSON, and binary (base64) formats.
|
|
|
|
Returns: {
|
|
success: boolean,
|
|
message: string,
|
|
meta: {
|
|
type: "text" | "json" | "binary",
|
|
created: string (ISO timestamp),
|
|
updated: string (ISO timestamp)
|
|
}
|
|
}`,
|
|
parameters: {
|
|
type: 'object',
|
|
properties: {
|
|
collection: {
|
|
type: 'string',
|
|
description: 'Collection name to organize related data (defaults to "no-collection" if not provided). Acts like a namespace.',
|
|
optional: true
|
|
},
|
|
key: {
|
|
type: 'string',
|
|
description: 'Unique identifier for the data within the collection. Must be a string.'
|
|
},
|
|
value: {
|
|
type: 'string',
|
|
description: 'The data to store. For format="text": any string. For format="json": valid JSON string. For format="binary": base64 encoded data.'
|
|
},
|
|
format: {
|
|
type: 'string',
|
|
description: 'Data format type. "text" for plain text (default), "json" for JSON data (validates structure), "binary" for base64 encoded binary data.',
|
|
enum: ['text', 'json', 'binary'],
|
|
optional: true
|
|
}
|
|
},
|
|
required: ['key', 'value']
|
|
},
|
|
function: async (params) => {
|
|
try {
|
|
const { collection = DEFAULT_COLLECTION, key, value, format = 'text' } = params;
|
|
logger.debug(`Tool::Memorize Storing ${key} in collection ${collection} as ${format}`);
|
|
const memoryEntry = createMemoryEntry(value, format);
|
|
await set(`${collection}:${key}`, memoryEntry, storagePath, collection);
|
|
return {
|
|
success: true,
|
|
message: `Stored ${key} in collection ${collection} as ${format}`,
|
|
meta: memoryEntry.meta
|
|
};
|
|
}
|
|
catch (error) {
|
|
logger.error('Error storing memory', error);
|
|
return {
|
|
success: false,
|
|
message: error instanceof Error ? error.message : 'Unknown error occurred'
|
|
};
|
|
}
|
|
},
|
|
parse: JSON.parse
|
|
}
|
|
},
|
|
{
|
|
type: 'function',
|
|
function: {
|
|
name: 'recall',
|
|
description: `Retrieve stored information from memory by collection and key, including format metadata.
|
|
|
|
Returns: {
|
|
success: boolean,
|
|
value?: string (the stored data),
|
|
meta?: {
|
|
type: "text" | "json" | "binary",
|
|
created: string (ISO timestamp),
|
|
updated: string (ISO timestamp)
|
|
},
|
|
key: string,
|
|
collection: string,
|
|
message?: string (error message if success=false)
|
|
}`,
|
|
parameters: {
|
|
type: 'object',
|
|
properties: {
|
|
collection: {
|
|
type: 'string',
|
|
description: 'Collection name to retrieve from (defaults to "no-collection" if not provided). Must match the collection used when storing.',
|
|
optional: true
|
|
},
|
|
key: {
|
|
type: 'string',
|
|
description: 'The unique identifier of the data to retrieve. Must match the key used when storing.'
|
|
}
|
|
},
|
|
required: ['key']
|
|
},
|
|
function: async (params) => {
|
|
try {
|
|
const { collection = DEFAULT_COLLECTION, key } = params;
|
|
logger.debug(`Tool::Recall Retrieving ${key} from collection ${collection}`);
|
|
const storedData = await get(`${collection}:${key}`, storagePath, collection);
|
|
if (storedData === undefined) {
|
|
return { success: false, message: `Key ${key} not found in collection ${collection}` };
|
|
}
|
|
// Handle both old format (plain string) and new format (MemoryEntry)
|
|
let memoryEntry;
|
|
if (typeof storedData === 'string') {
|
|
// Legacy format - convert to new format
|
|
memoryEntry = {
|
|
value: storedData,
|
|
meta: {
|
|
type: 'text',
|
|
created: new Date().toISOString(),
|
|
updated: new Date().toISOString()
|
|
}
|
|
};
|
|
}
|
|
else {
|
|
memoryEntry = storedData;
|
|
}
|
|
return {
|
|
success: true,
|
|
value: memoryEntry.value,
|
|
meta: memoryEntry.meta,
|
|
key,
|
|
collection
|
|
};
|
|
}
|
|
catch (error) {
|
|
logger.error('Error retrieving memory', error);
|
|
return {
|
|
success: false,
|
|
message: error instanceof Error ? error.message : 'Unknown error occurred'
|
|
};
|
|
}
|
|
},
|
|
parse: JSON.parse
|
|
}
|
|
},
|
|
{
|
|
type: 'function',
|
|
function: {
|
|
name: 'forget',
|
|
description: `Remove a specific key from memory collection.
|
|
|
|
Returns: {
|
|
success: boolean,
|
|
message: string (confirmation or error message)
|
|
}`,
|
|
parameters: {
|
|
type: 'object',
|
|
properties: {
|
|
collection: {
|
|
type: 'string',
|
|
description: 'Collection name to remove from (defaults to "no-collection" if not provided). Must match the collection where the key was stored.',
|
|
optional: true
|
|
},
|
|
key: {
|
|
type: 'string',
|
|
description: 'The unique identifier of the data to remove. Must match exactly the key used when storing.'
|
|
}
|
|
},
|
|
required: ['key']
|
|
},
|
|
function: async (params) => {
|
|
try {
|
|
const { collection = DEFAULT_COLLECTION, key } = params;
|
|
logger.debug(`Tool::Forget Removing ${key} from collection ${collection}`);
|
|
const keyv = store(storagePath, collection);
|
|
const deleted = await keyv.delete(`${collection}:${key}`);
|
|
return { success: deleted, message: deleted ? `Removed ${key} from ${collection}` : `Key ${key} not found in ${collection}` };
|
|
}
|
|
catch (error) {
|
|
logger.error('Error removing from memory', error);
|
|
return {
|
|
success: false,
|
|
message: error instanceof Error ? error.message : 'Unknown error occurred'
|
|
};
|
|
}
|
|
},
|
|
parse: JSON.parse
|
|
}
|
|
},
|
|
{
|
|
type: 'function',
|
|
function: {
|
|
name: 'list_memories',
|
|
description: `List all keys in a specific collection using Keyv's iterator method.
|
|
|
|
Returns: {
|
|
success: boolean,
|
|
collection: string (the collection name),
|
|
keys: string[] (array of key names in the collection),
|
|
entries: Array<{
|
|
key: string,
|
|
meta?: {
|
|
type: "text" | "json" | "binary",
|
|
created: string (ISO timestamp),
|
|
updated: string (ISO timestamp)
|
|
}
|
|
}>,
|
|
count: number (total number of keys),
|
|
message?: string (info or error message)
|
|
}`,
|
|
parameters: {
|
|
type: 'object',
|
|
properties: {
|
|
collection: {
|
|
type: 'string',
|
|
description: 'Collection name to list keys from (defaults to "no-collection" if not provided). Will return all keys stored in this collection namespace.',
|
|
optional: true
|
|
}
|
|
},
|
|
required: []
|
|
},
|
|
function: async (params) => {
|
|
try {
|
|
const { collection = DEFAULT_COLLECTION } = params;
|
|
logger.debug(`Tool::ListMemories Listing keys in collection ${collection}`);
|
|
// Create a Keyv instance for the specific collection to use iterator
|
|
const keyv = store(storagePath, collection);
|
|
const keys = [];
|
|
const entries = [];
|
|
try {
|
|
// Check if iterator method exists and use it
|
|
if (typeof keyv.iterator === 'function') {
|
|
try {
|
|
// Try calling iterator without arguments first
|
|
const iterator = keyv.iterator();
|
|
for await (const [key, value] of iterator) {
|
|
// Remove the collection prefix from the key to get the clean key name
|
|
const cleanKey = key.replace(`${collection}:`, '');
|
|
keys.push(cleanKey);
|
|
// Try to extract metadata if it's a MemoryEntry
|
|
let meta = undefined;
|
|
if (value && typeof value === 'object' && value.meta) {
|
|
meta = value.meta;
|
|
}
|
|
entries.push({ key: cleanKey, meta });
|
|
}
|
|
}
|
|
catch (iteratorCallError) {
|
|
logger.warn(`Tool::ListMemories Iterator call failed:`, iteratorCallError);
|
|
// Fall through to the not available case
|
|
return {
|
|
success: true,
|
|
collection,
|
|
keys: [],
|
|
entries: [],
|
|
count: 0,
|
|
message: 'Iterator call failed. Unable to list keys.'
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
// Iterator not available, provide helpful message
|
|
logger.warn(`Tool::ListMemories Iterator method not available for Keyv instance`);
|
|
return {
|
|
success: true,
|
|
collection,
|
|
keys: [],
|
|
entries: [],
|
|
count: 0,
|
|
message: 'Iterator method not available in this Keyv version. Use individual key operations instead.'
|
|
};
|
|
}
|
|
return {
|
|
success: true,
|
|
collection,
|
|
keys,
|
|
entries,
|
|
count: keys.length
|
|
};
|
|
}
|
|
catch (iteratorError) {
|
|
// If iterator fails, fall back to returning basic info
|
|
logger.warn(`Tool::ListMemories Iterator failed for collection ${collection}:`, iteratorError);
|
|
return {
|
|
success: true,
|
|
collection,
|
|
keys: [],
|
|
entries: [],
|
|
count: 0,
|
|
message: 'Iterator failed or collection is empty'
|
|
};
|
|
}
|
|
}
|
|
catch (error) {
|
|
logger.error('Error listing memories', error);
|
|
return {
|
|
success: false,
|
|
message: error instanceof Error ? error.message : 'Unknown error occurred'
|
|
};
|
|
}
|
|
},
|
|
parse: JSON.parse
|
|
}
|
|
}
|
|
];
|
|
};
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../../src/lib/tools/memory.ts"],"names":[],"mappings":"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"}
|