@xynehq/jaf/dist/memory/types.js

Juspay Agent Framework - A purely functional agent framework with immutable state and composable tools

import { z } from 'zod';
// Configuration schemas for different providers
export const InMemoryConfigSchema = z.object({
    type: z.literal('memory'),
    maxConversations: z.number().default(1000),
    maxMessagesPerConversation: z.number().default(1000)
});
export const RedisConfigSchema = z.object({
    type: z.literal('redis'),
    url: z.string().optional(),
    host: z.string().default('localhost'),
    port: z.number().default(6379),
    password: z.string().optional(),
    db: z.number().default(0),
    keyPrefix: z.string().default('jaf:memory:'),
    ttl: z.number().optional() // seconds
});
export const PostgresConfigSchema = z.object({
    type: z.literal('postgres'),
    connectionString: z.string().optional(),
    host: z.string().default('localhost'),
    port: z.number().default(5432),
    database: z.string().default('jaf_memory'),
    username: z.string().default('postgres'),
    password: z.string().optional(),
    ssl: z.boolean().default(false),
    tableName: z.string().default('conversations'),
    maxConnections: z.number().default(10)
});
export const MemoryProviderConfigSchema = z.union([
    InMemoryConfigSchema,
    RedisConfigSchema,
    PostgresConfigSchema
]);
// Error factory functions
export const createMemoryError = (message, code, provider, cause) => ({
    _tag: 'MemoryError',
    message,
    code,
    provider,
    cause
});
export const createMemoryConnectionError = (provider, cause) => ({
    _tag: 'MemoryConnectionError',
    message: `Failed to connect to ${provider} memory provider`,
    provider,
    cause
});
export const createMemoryNotFoundError = (conversationId, provider) => ({
    _tag: 'MemoryNotFoundError',
    message: `Conversation ${conversationId} not found`,
    conversationId,
    provider
});
export const createMemoryStorageError = (operation, provider, cause) => ({
    _tag: 'MemoryStorageError',
    message: `Failed to ${operation} in ${provider}`,
    operation,
    provider,
    cause
});
// Error checking functions
export const isMemoryError = (error) => {
    return error && typeof error === 'object' && '_tag' in error &&
        (error._tag === 'MemoryConnectionError' ||
            error._tag === 'MemoryNotFoundError' ||
            error._tag === 'MemoryStorageError');
};
export const isMemoryConnectionError = (error) => {
    return error && error._tag === 'MemoryConnectionError';
};
export const isMemoryNotFoundError = (error) => {
    return error && error._tag === 'MemoryNotFoundError';
};
export const isMemoryStorageError = (error) => {
    return error && error._tag === 'MemoryStorageError';
};
// Result helper functions
export const createSuccess = (data) => ({
    success: true,
    data
});
export const createFailure = (error) => ({
    success: false,
    error
});
export const isSuccess = (result) => {
    return result.success;
};
export const isFailure = (result) => {
    return !result.success;
};
//# sourceMappingURL=types.js.map